commit 166cb9e9f48ca1e05ea3c4579b50f87ffb674f50
Author: Silentkiller159 <milanhotovec@seznam.cz>
Date:   Thu May 13 22:33:24 2021 +0200

    Completed data layer with migrations. With flags

diff --git a/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513145537_Added-GlobalArea.Designer.cs b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513145537_Added-GlobalArea.Designer.cs
new file mode 100644
index 0000000..6a5d411
--- /dev/null
+++ b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513145537_Added-GlobalArea.Designer.cs
@@ -0,0 +1,744 @@
+﻿// <auto-generated />
+using System;
+using Leuze.Core.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Leuze.Core.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(LeuzeDbContext))]
+    [Migration("20210513145537_Added-GlobalArea")]
+    partial class AddedGlobalArea
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("ProductVersion", "5.0.4")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("ApplicationPermissionApplicationRole", b =>
+                {
+                    b.Property<Guid>("PermissionsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("RolesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("PermissionsId", "RolesId");
+
+                    b.HasIndex("RolesId");
+
+                    b.ToTable("Leuze_Roles_Assigned_Permissions");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationPermission", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Module")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("nvarchar(512)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("nvarchar(512)");
+
+                    b.Property<string>("Privilege")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("nvarchar(2048)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Leuze_Application_Permissions");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationRole", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("Leuze_Roles");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationRoleClaim", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsAdUser")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("Leuze_Users");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserClaim", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserLogin", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserRole", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserToken", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Domain.Domains.Users.DomainUser", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("SeniorUserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("SeniorUserId");
+
+                    b.ToTable("Leuze_Domain_Users");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.Comment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GoalId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsChanged")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsPrivate")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GoalId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_Comments");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("From")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("To")
+                        .HasColumnType("datetime2");
+
+                    b.Property<double?>("VariCompanySuccess")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalDefinitionAreas");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("FinanceBase")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("GDAreaId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("nvarchar(255)");
+
+                    b.Property<Guid>("OwnerId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("OwnerLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("SupervisorLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<double?>("VariProjectHours")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GDAreaId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalDefinitions");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("GoalDefinitionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("nvarchar(255)");
+
+                    b.Property<double>("PercentileFinal")
+                        .HasColumnType("float");
+
+                    b.Property<double>("PercentileUser")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GoalDefinitionId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalItems");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalUpdate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GoalId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("NewValue")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OldValue")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("UpdatedType")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GoalId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalUpdates");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.Review", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("CommentCreator")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CommentOwner")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GoalId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsFinal")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GoalId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_Reviews");
+                });
+
+            modelBuilder.Entity("ApplicationPermissionApplicationRole", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationPermission", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationRole", null)
+                        .WithMany()
+                        .HasForeignKey("RolesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationRoleClaim", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserClaim", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserLogin", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserRole", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationRole", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserToken", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Domain.Domains.Users.DomainUser", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "SeniorUser")
+                        .WithMany("Juniors")
+                        .HasForeignKey("SeniorUserId");
+
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", "User")
+                        .WithOne()
+                        .HasForeignKey("Leuze.Core.Domain.Domains.Users.DomainUser", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Leuze.Core.Domain.Domains.Shared.ValueObjects.EmailAddress", "EmailAddress", b1 =>
+                        {
+                            b1.Property<Guid>("DomainUserUserId")
+                                .HasColumnType("uniqueidentifier");
+
+                            b1.Property<string>("Email")
+                                .IsRequired()
+                                .HasMaxLength(512)
+                                .HasColumnType("nvarchar(512)");
+
+                            b1.HasKey("DomainUserUserId");
+
+                            b1.ToTable("Leuze_Domain_Users");
+
+                            b1.WithOwner()
+                                .HasForeignKey("DomainUserUserId");
+                        });
+
+                    b.OwnsOne("Leuze.Core.Domain.Domains.Shared.ValueObjects.PersonFullName", "Name", b1 =>
+                        {
+                            b1.Property<Guid>("DomainUserUserId")
+                                .HasColumnType("uniqueidentifier");
+
+                            b1.Property<string>("FullName")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("nvarchar(256)");
+
+                            b1.HasKey("DomainUserUserId");
+
+                            b1.ToTable("Leuze_Domain_Users");
+
+                            b1.WithOwner()
+                                .HasForeignKey("DomainUserUserId");
+                        });
+
+                    b.Navigation("EmailAddress")
+                        .IsRequired();
+
+                    b.Navigation("Name")
+                        .IsRequired();
+
+                    b.Navigation("SeniorUser");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.Comment", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GoalItem", "Goal")
+                        .WithMany("Comments")
+                        .HasForeignKey("GoalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Goal");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", "GDArea")
+                        .WithMany()
+                        .HasForeignKey("GDAreaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("GDArea");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalItem", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", "GoalDefinition")
+                        .WithMany("Goals")
+                        .HasForeignKey("GoalDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("GoalDefinition");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalUpdate", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GoalItem", "Goal")
+                        .WithMany("Updates")
+                        .HasForeignKey("GoalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Goal");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.Review", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GoalItem", "Goal")
+                        .WithMany("Reviews")
+                        .HasForeignKey("GoalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Goal");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Domain.Domains.Users.DomainUser", b =>
+                {
+                    b.Navigation("Juniors");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
+                {
+                    b.Navigation("Goals");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalItem", b =>
+                {
+                    b.Navigation("Comments");
+
+                    b.Navigation("Reviews");
+
+                    b.Navigation("Updates");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513145537_Added-GlobalArea.cs b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513145537_Added-GlobalArea.cs
new file mode 100644
index 0000000..f50254e
--- /dev/null
+++ b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513145537_Added-GlobalArea.cs
@@ -0,0 +1,160 @@
+﻿using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Leuze.Core.Infrastructure.Persistence.Migrations
+{
+    public partial class AddedGlobalArea : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "From",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.DropColumn(
+                name: "To",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.DropColumn(
+                name: "Vari",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.AlterColumn<double>(
+                name: "PercentileUser",
+                table: "Leuze_Modules_Goal_Domain_GoalItems",
+                type: "float",
+                nullable: false,
+                oldClrType: typeof(decimal),
+                oldType: "decimal(18,2)");
+
+            migrationBuilder.AlterColumn<double>(
+                name: "PercentileFinal",
+                table: "Leuze_Modules_Goal_Domain_GoalItems",
+                type: "float",
+                nullable: false,
+                oldClrType: typeof(decimal),
+                oldType: "decimal(18,2)");
+
+            migrationBuilder.AddColumn<double>(
+                name: "FinanceBase",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                type: "float",
+                nullable: false,
+                defaultValue: 0.0);
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "GDAreaId",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                type: "uniqueidentifier",
+                nullable: false,
+                defaultValue: new Guid("00000000-0000-0000-0000-000000000000"));
+
+            migrationBuilder.AddColumn<double>(
+                name: "VariProjectHours",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                type: "float",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "Leuze_Modules_Goal_Domain_GoalDefinitionAreas",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    CreatorId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    From = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    To = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    VariCompanySuccess = table.Column<double>(type: "float", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Leuze_Modules_Goal_Domain_GoalDefinitionAreas", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Leuze_Modules_Goal_Domain_GoalDefinitionAreas_Leuze_Domain_Users_CreatorId",
+                        column: x => x.CreatorId,
+                        principalTable: "Leuze_Domain_Users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Leuze_Modules_Goal_Domain_GoalDefinitions_GDAreaId",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                column: "GDAreaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Leuze_Modules_Goal_Domain_GoalDefinitionAreas_CreatorId",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitionAreas",
+                column: "CreatorId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Leuze_Modules_Goal_Domain_GoalDefinitions_Leuze_Modules_Goal_Domain_GoalDefinitionAreas_GDAreaId",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                column: "GDAreaId",
+                principalTable: "Leuze_Modules_Goal_Domain_GoalDefinitionAreas",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Leuze_Modules_Goal_Domain_GoalDefinitions_Leuze_Modules_Goal_Domain_GoalDefinitionAreas_GDAreaId",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.DropTable(
+                name: "Leuze_Modules_Goal_Domain_GoalDefinitionAreas");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Leuze_Modules_Goal_Domain_GoalDefinitions_GDAreaId",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.DropColumn(
+                name: "FinanceBase",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.DropColumn(
+                name: "GDAreaId",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.DropColumn(
+                name: "VariProjectHours",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.AlterColumn<decimal>(
+                name: "PercentileUser",
+                table: "Leuze_Modules_Goal_Domain_GoalItems",
+                type: "decimal(18,2)",
+                nullable: false,
+                oldClrType: typeof(double),
+                oldType: "float");
+
+            migrationBuilder.AlterColumn<decimal>(
+                name: "PercentileFinal",
+                table: "Leuze_Modules_Goal_Domain_GoalItems",
+                type: "decimal(18,2)",
+                nullable: false,
+                oldClrType: typeof(double),
+                oldType: "float");
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "From",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "To",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "Vari",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                type: "decimal(18,2)",
+                nullable: true);
+        }
+    }
+}
diff --git a/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513201935_Added-CreatedAt.Designer.cs b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513201935_Added-CreatedAt.Designer.cs
new file mode 100644
index 0000000..2b35158
--- /dev/null
+++ b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513201935_Added-CreatedAt.Designer.cs
@@ -0,0 +1,768 @@
+﻿// <auto-generated />
+using System;
+using Leuze.Core.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Leuze.Core.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(LeuzeDbContext))]
+    [Migration("20210513201935_Added-CreatedAt")]
+    partial class AddedCreatedAt
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("ProductVersion", "5.0.4")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("ApplicationPermissionApplicationRole", b =>
+                {
+                    b.Property<Guid>("PermissionsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("RolesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("PermissionsId", "RolesId");
+
+                    b.HasIndex("RolesId");
+
+                    b.ToTable("Leuze_Roles_Assigned_Permissions");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationPermission", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Module")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("nvarchar(512)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("nvarchar(512)");
+
+                    b.Property<string>("Privilege")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("nvarchar(2048)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Leuze_Application_Permissions");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationRole", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("Leuze_Roles");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationRoleClaim", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsAdUser")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("Leuze_Users");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserClaim", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserLogin", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserRole", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserToken", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Domain.Domains.Users.DomainUser", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("SeniorUserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("SeniorUserId");
+
+                    b.ToTable("Leuze_Domain_Users");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.Comment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GoalId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsChanged")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsPrivate")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GoalId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_Comments");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("From")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("To")
+                        .HasColumnType("datetime2");
+
+                    b.Property<double?>("VariCompanySuccess")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalDefinitionAreas");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("FinanceBase")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("GDAreaId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("nvarchar(255)");
+
+                    b.Property<Guid>("OwnerId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("OwnerLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("SupervisorLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<double?>("VariProjectHours")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GDAreaId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalDefinitions");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("GoalDefinitionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("nvarchar(255)");
+
+                    b.Property<bool>("OwnerLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<double>("PercentileFinal")
+                        .HasColumnType("float");
+
+                    b.Property<double>("PercentileUser")
+                        .HasColumnType("float");
+
+                    b.Property<bool>("SupervisorLocked")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GoalDefinitionId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalItems");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalUpdate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GoalId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("NewValue")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OldValue")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("UpdatedType")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GoalId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalUpdates");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.Review", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("CommentCreator")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CommentOwner")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GoalId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsFinal")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("GoalId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_Reviews");
+                });
+
+            modelBuilder.Entity("ApplicationPermissionApplicationRole", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationPermission", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationRole", null)
+                        .WithMany()
+                        .HasForeignKey("RolesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationRoleClaim", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserClaim", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserLogin", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserRole", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationRole", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Application.Identity.ApplicationUserToken", b =>
+                {
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Leuze.Core.Domain.Domains.Users.DomainUser", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "SeniorUser")
+                        .WithMany("Juniors")
+                        .HasForeignKey("SeniorUserId");
+
+                    b.HasOne("Leuze.Core.Application.Identity.ApplicationUser", "User")
+                        .WithOne()
+                        .HasForeignKey("Leuze.Core.Domain.Domains.Users.DomainUser", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Leuze.Core.Domain.Domains.Shared.ValueObjects.EmailAddress", "EmailAddress", b1 =>
+                        {
+                            b1.Property<Guid>("DomainUserUserId")
+                                .HasColumnType("uniqueidentifier");
+
+                            b1.Property<string>("Email")
+                                .IsRequired()
+                                .HasMaxLength(512)
+                                .HasColumnType("nvarchar(512)");
+
+                            b1.HasKey("DomainUserUserId");
+
+                            b1.ToTable("Leuze_Domain_Users");
+
+                            b1.WithOwner()
+                                .HasForeignKey("DomainUserUserId");
+                        });
+
+                    b.OwnsOne("Leuze.Core.Domain.Domains.Shared.ValueObjects.PersonFullName", "Name", b1 =>
+                        {
+                            b1.Property<Guid>("DomainUserUserId")
+                                .HasColumnType("uniqueidentifier");
+
+                            b1.Property<string>("FullName")
+                                .IsRequired()
+                                .HasMaxLength(256)
+                                .HasColumnType("nvarchar(256)");
+
+                            b1.HasKey("DomainUserUserId");
+
+                            b1.ToTable("Leuze_Domain_Users");
+
+                            b1.WithOwner()
+                                .HasForeignKey("DomainUserUserId");
+                        });
+
+                    b.Navigation("EmailAddress")
+                        .IsRequired();
+
+                    b.Navigation("Name")
+                        .IsRequired();
+
+                    b.Navigation("SeniorUser");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.Comment", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GoalItem", "Goal")
+                        .WithMany("Comments")
+                        .HasForeignKey("GoalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Goal");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", "GDArea")
+                        .WithMany()
+                        .HasForeignKey("GDAreaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("GDArea");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalItem", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", "GoalDefinition")
+                        .WithMany("Goals")
+                        .HasForeignKey("GoalDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("GoalDefinition");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalUpdate", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GoalItem", "Goal")
+                        .WithMany("Updates")
+                        .HasForeignKey("GoalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Goal");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.Review", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GoalItem", "Goal")
+                        .WithMany("Reviews")
+                        .HasForeignKey("GoalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Goal");
+                });
+
+            modelBuilder.Entity("Leuze.Core.Domain.Domains.Users.DomainUser", b =>
+                {
+                    b.Navigation("Juniors");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
+                {
+                    b.Navigation("Goals");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalItem", b =>
+                {
+                    b.Navigation("Comments");
+
+                    b.Navigation("Reviews");
+
+                    b.Navigation("Updates");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513201935_Added-CreatedAt.cs b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513201935_Added-CreatedAt.cs
new file mode 100644
index 0000000..6bdaa51
--- /dev/null
+++ b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/20210513201935_Added-CreatedAt.cs
@@ -0,0 +1,102 @@
+﻿using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Leuze.Core.Infrastructure.Persistence.Migrations
+{
+    public partial class AddedCreatedAt : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_Reviews",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_GoalUpdates",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_GoalItems",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<bool>(
+                name: "OwnerLocked",
+                table: "Leuze_Modules_Goal_Domain_GoalItems",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "SupervisorLocked",
+                table: "Leuze_Modules_Goal_Domain_GoalItems",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitionAreas",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_Comments",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_Reviews");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_GoalUpdates");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_GoalItems");
+
+            migrationBuilder.DropColumn(
+                name: "OwnerLocked",
+                table: "Leuze_Modules_Goal_Domain_GoalItems");
+
+            migrationBuilder.DropColumn(
+                name: "SupervisorLocked",
+                table: "Leuze_Modules_Goal_Domain_GoalItems");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitions");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_GoalDefinitionAreas");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "Leuze_Modules_Goal_Domain_Comments");
+        }
+    }
+}
diff --git a/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/LeuzeDbContextModelSnapshot.cs b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/LeuzeDbContextModelSnapshot.cs
index a277899..b5de9ec 100644
--- a/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/LeuzeDbContextModelSnapshot.cs
+++ b/src/Core/Infrastructure/Leuze.Core.Infrastructure.Persistence/Migrations/LeuzeDbContextModelSnapshot.cs
@@ -282,6 +282,9 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uniqueidentifier");
 
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
                     b.Property<Guid>("CreatorId")
                         .HasColumnType("uniqueidentifier");
 
@@ -307,18 +310,52 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                     b.ToTable("Leuze_Modules_Goal_Domain_Comments");
                 });
 
-            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", b =>
                 {
                     b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uniqueidentifier");
 
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
                     b.Property<Guid>("CreatorId")
                         .HasColumnType("uniqueidentifier");
 
                     b.Property<DateTime>("From")
                         .HasColumnType("datetime2");
 
+                    b.Property<DateTime>("To")
+                        .HasColumnType("datetime2");
+
+                    b.Property<double?>("VariCompanySuccess")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.ToTable("Leuze_Modules_Goal_Domain_GoalDefinitionAreas");
+                });
+
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("FinanceBase")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("GDAreaId")
+                        .HasColumnType("uniqueidentifier");
+
                     b.Property<string>("Name")
                         .IsRequired()
                         .HasMaxLength(255)
@@ -333,16 +370,15 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                     b.Property<bool>("SupervisorLocked")
                         .HasColumnType("bit");
 
-                    b.Property<DateTime>("To")
-                        .HasColumnType("datetime2");
-
-                    b.Property<decimal?>("Vari")
-                        .HasColumnType("decimal(18,2)");
+                    b.Property<double?>("VariProjectHours")
+                        .HasColumnType("float");
 
                     b.HasKey("Id");
 
                     b.HasIndex("CreatorId");
 
+                    b.HasIndex("GDAreaId");
+
                     b.HasIndex("OwnerId");
 
                     b.ToTable("Leuze_Modules_Goal_Domain_GoalDefinitions");
@@ -354,6 +390,9 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uniqueidentifier");
 
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
                     b.Property<Guid>("CreatorId")
                         .HasColumnType("uniqueidentifier");
 
@@ -369,11 +408,17 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                         .HasMaxLength(255)
                         .HasColumnType("nvarchar(255)");
 
-                    b.Property<decimal>("PercentileFinal")
-                        .HasColumnType("decimal(18,2)");
+                    b.Property<bool>("OwnerLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<double>("PercentileFinal")
+                        .HasColumnType("float");
 
-                    b.Property<decimal>("PercentileUser")
-                        .HasColumnType("decimal(18,2)");
+                    b.Property<double>("PercentileUser")
+                        .HasColumnType("float");
+
+                    b.Property<bool>("SupervisorLocked")
+                        .HasColumnType("bit");
 
                     b.HasKey("Id");
 
@@ -390,6 +435,9 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uniqueidentifier");
 
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
                     b.Property<Guid>("CreatorId")
                         .HasColumnType("uniqueidentifier");
 
@@ -430,6 +478,9 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                         .IsRequired()
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
                     b.Property<Guid>("CreatorId")
                         .HasColumnType("uniqueidentifier");
 
@@ -596,6 +647,17 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                     b.Navigation("Goal");
                 });
 
+            modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", b =>
+                {
+                    b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
             modelBuilder.Entity("Leuze.Modules.Goal.Domain.Domains.GoalDefinition", b =>
                 {
                     b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Creator")
@@ -604,6 +666,12 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.HasOne("Leuze.Modules.Goal.Domain.Domains.GlobalDefinitionArea", "GDArea")
+                        .WithMany()
+                        .HasForeignKey("GDAreaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
                     b.HasOne("Leuze.Core.Domain.Domains.Users.DomainUser", "Owner")
                         .WithMany()
                         .HasForeignKey("OwnerId")
@@ -612,6 +680,8 @@ namespace Leuze.Core.Infrastructure.Persistence.Migrations
 
                     b.Navigation("Creator");
 
+                    b.Navigation("GDArea");
+
                     b.Navigation("Owner");
                 });
 
diff --git a/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/Components/CreateGoalAside.razor b/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/Components/CreateGoalAside.razor
index 579dc35..de14ac6 100644
--- a/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/Components/CreateGoalAside.razor
+++ b/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/Components/CreateGoalAside.razor
@@ -18,7 +18,7 @@
     </div>
     <div class="review_detail_footer">
         <button @onclick="Create">Vytvořit</button>
-        <button>Zrušit</button>
+        <button @onclick="Close">Zrušit</button>
     </div>
 </aside>
 
@@ -125,9 +125,9 @@
 
     private string _aside;
 
-    public string Name { get; set; }
+    public string Name { get; set; } = "";
 
-    public string Description { get; set; }
+    public string Description { get; set; } = "";
 
     [Parameter]
     public bool Show { get; set; } = false;
@@ -143,16 +143,23 @@
 
     private async Task Create()
     {
+        if(Name == "")
+        {
+            toastService.ShowError("Nelze vytvořit cíl bez názvu!");
+            return;
+        }
         var response = await _mediator.Send(new CreateGoal.Command(DefinitionId, Name, Description));
 
         if (response.IsSuccess)
         {
             toastService.ShowSuccess("Cíl úspěšně vytvořen");
             await LoadGoalsInDefinitionView.InvokeAsync();
+            await Close();
+
+            Name = "";
+            Description = "";
         }
         else toastService.ShowError("Cíl se nepodařilo vytvořit");
-
-        await Close();
     }
 
     private async Task Close()
diff --git a/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/GoalDefinitionDetail.razor b/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/GoalDefinitionDetail.razor
index 434de4b..45830f4 100644
--- a/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/GoalDefinitionDetail.razor
+++ b/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/GoalDefinitionDetail.razor
@@ -5,10 +5,10 @@
 
 <div class="section_header">
     <div>
-        <h2>Název definice cílů</h2>
+        <h2>@_definition.Name</h2>
         <div class="definition_daterange">
             <i class="fal fa-clock"></i>
-            13.2.2021 - 12.2.2022
+            @_definition.GDArea.From.ToShortDateString() - @_definition.GDArea.To.ToShortDateString()
         </div>
     </div>
     <div class="header_buttons">
@@ -161,6 +161,8 @@ else
     [Parameter]
     public Guid Id { get; set; }
 
+    private GoalDefinition _definition = GoalDefinition.Default();
+
     public List<GoalItem> Goals { get; set; } = new();
 
     public Guid DetailId { get; set; } = default(Guid);
@@ -175,6 +177,16 @@ else
 
     private void CloseCreateAside() => ShowCreate = false;
 
+    private async Task GetDefinitionInfo()
+    {
+        var response = await _mediator.Send(new GetGoalDefinitionById.Query(Id));
+
+        if (response.IsSuccess)
+        {
+            _definition = response.Result.item;
+        }
+    }
+
     private async Task GetGoals()
     {
         var response = await _mediator.Send(new GetGoalsForDefinition.Query(Id));
@@ -188,6 +200,7 @@ else
     protected async override Task OnInitializedAsync()
     {
         await base.OnInitializedAsync();
+        await GetDefinitionInfo();
         await GetGoals();
     }
 
diff --git a/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/MyGoalDefinition.razor b/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/MyGoalDefinition.razor
index 91f1f40..c741ba1 100644
--- a/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/MyGoalDefinition.razor
+++ b/src/Modules/Goal/Application/Leuze.Modules.Goal.Application.UI/Pages/MyGoalDefinition.razor
@@ -13,6 +13,8 @@
         <tr>
             <th>Název</th>
             <th>Vytvořil</th>
+            <th>Splněnost cílů</th>
+            <th>Končí</th>
             <th>Akce</th>
         </tr>
         @foreach (var range in Definitions)
@@ -20,6 +22,8 @@
             <tr>
                 <td>@range.Name</td>
                 <td>@range.Creator.Name</td>
+                <td>@(range.Goals.Count > 0 ? range.Goals.Sum(item => item.PercentileFinal) / range.Goals.Count : 0)%</td>
+                <td>@range.GDArea.To.ToShortDateString()</td>
                 <td>
                     <div class="flex">
                         <div></div>
diff --git a/src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/GoalDefinitions/Queries/GetGoalDefinitionById.cs b/src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/GoalDefinitions/Queries/GetGoalDefinitionById.cs
index 0c289f7..ad5f008 100644
--- a/src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/GoalDefinitions/Queries/GetGoalDefinitionById.cs
+++ b/src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/GoalDefinitions/Queries/GetGoalDefinitionById.cs
@@ -11,36 +11,26 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Leuze.Modules.Goal.Application.CQRS.Goals.Commands
+namespace Leuze.Modules.Goal.Application.CQRS.Goals.Queries
 {
     public static class GetGoalDefinitionById
     {
-        public record Command(Guid GoalDefinitionId, string Name, string Description) : IBaseRequest<Response>;
+        public record Query(Guid GoalDefinitionId) : IBaseRequest<Response>;
 
-        public record Response(GoalItem item);
+        public record Response(GoalDefinition item);
 
 
-        public class Handler : IBaseRequestHandler<Command, Response>
+        public class Handler : IBaseRequestHandler<Query, Response>
         {
-            private readonly IGoalItemRepository _goalItemRepo;
             private readonly IGoalDefinitionRepository _goalDefinitionRepo;
-            private readonly AuthenticationStateProvider _authenticationStateProvider;
-            private readonly IDomainUserRepository _domainUserRepo;
 
-            public Handler(IGoalItemRepository goalItemRepo, IGoalDefinitionRepository goalDefinitionRepo, AuthenticationStateProvider authStateProvider, IDomainUserRepository domainUserRepo)
+            public Handler(IGoalDefinitionRepository goalDefinitionRepo)
             {
-                _goalItemRepo = goalItemRepo;
                 _goalDefinitionRepo = goalDefinitionRepo;
-                _authenticationStateProvider = authStateProvider;
-                _domainUserRepo = domainUserRepo;
             }
 
-            public async Task<RequestResponse<Response>> Handle(Command request, CancellationToken cancellationToken)
+            public async Task<RequestResponse<Response>> Handle(Query request, CancellationToken cancellationToken)
             {
-                //TODO: user muze byt null, ale to my nechceme!!!
-                var state = await _authenticationStateProvider.GetAuthenticationStateAsync();
-                var id = Guid.Parse(state.User!.FindFirst(ClaimTypes.NameIdentifier)!.Value);
-                var user = await _domainUserRepo.GetByIdAsync(id);
                 var goalDef = await _goalDefinitionRepo.GetByIdAsync(request.GoalDefinitionId);
 
                 if(goalDef == null)
@@ -48,11 +38,7 @@ namespace Leuze.Modules.Goal.Application.CQRS.Goals.Commands
                     return RequestResponse<Response>.CreateErrorResponse($"Goal definition with id: {request.GoalDefinitionId} not found!");
                 }
 
-                GoalItem item = new(goalDef, user, request.Name, request.Description);
-
-                await _goalItemRepo.AddAsync(item);
-
-                return RequestResponse<Response>.CreateSuccessResponse(new(item));
+                return RequestResponse<Response>.CreateSuccessResponse(new(goalDef));
             }
         }
 
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/Comment.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/Comment.cs
index 5d9698d..cb0479f 100644
--- a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/Comment.cs
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/Comment.cs
@@ -26,17 +26,29 @@ namespace Leuze.Modules.Goal.Domain.Domains
         }
 
         public Guid Id { get; private set; }
+        public DateTime CreatedAt { get; private set; } = DateTime.Now;
         public DomainUser Creator { get; private set; }
         public Guid CreatorId { get; private set; }
         public GoalItem Goal { get; private set; }
         public Guid GoalId { get; private set; }
         public string Text { get; private set; }
         public bool IsPrivate { get; private set; }
-        public bool IsChanged { get; set; }
+        public bool IsChanged { get; private set; }
 
         public void SetText(string text)
         {
             this.Text = text;
+            this.IsChanged = true;
+        }
+
+        public void SetPrivate()
+        {
+            this.IsPrivate = true;
+        }
+
+        public void SetPublic()
+        {
+            this.IsPrivate = false;
         }
     }
 }
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GlobalDefinitionArea.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GlobalDefinitionArea.cs
new file mode 100644
index 0000000..a582616
--- /dev/null
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GlobalDefinitionArea.cs
@@ -0,0 +1,56 @@
+﻿using Leuze.Core.Domain.Domains;
+using Leuze.Core.Domain.Domains.Users;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Leuze.Modules.Goal.Domain.Domains
+{
+    public class GlobalDefinitionArea : BaseEntity
+    {
+        private GlobalDefinitionArea()
+        {
+
+        }
+
+        public GlobalDefinitionArea(DomainUser creator, DateTime from, DateTime to)
+        {
+            this.Creator = creator;
+            this.CreatorId = creator.UserId;
+            this.From = from;
+            this.To = to;
+            this.VariCompanySuccess = 0;
+        }
+
+        public static GlobalDefinitionArea Default()
+        {
+            return new GlobalDefinitionArea();
+        }
+
+        public Guid Id { get; private set; }
+        public DateTime CreatedAt { get; private set; } = DateTime.Now;
+        public DomainUser Creator { get; private set; }
+        public Guid CreatorId { get; private set; }
+        public DateTime From { get; private set; }
+        public DateTime To { get; private set; }
+        public double? VariCompanySuccess { get; private set; }
+
+
+        public void SetFrom(DateTime from)
+        {
+            this.From = from;
+        }
+
+        public void SetTo(DateTime to)
+        {
+            this.To = to;
+        }
+
+        public void SetVariCompanySuccess(double vari)
+        {
+            this.VariCompanySuccess = vari;
+        }
+    }
+}
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalDefinition.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalDefinition.cs
index 010ba73..75c3e04 100644
--- a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalDefinition.cs
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalDefinition.cs
@@ -16,28 +16,40 @@ namespace Leuze.Modules.Goal.Domain.Domains
 
         }
 
-        public GoalDefinition(DomainUser owner, DomainUser creator, string name, DateTime from, DateTime to)
+        public GoalDefinition(DomainUser owner, DomainUser creator, GlobalDefinitionArea gdArea, string name) : this(owner, creator, gdArea, name, 0)
+        {           
+        }
+
+        public GoalDefinition(DomainUser owner, DomainUser creator, GlobalDefinitionArea gdArea, string name, double financeBase)
         {
             this.Owner = owner;
             this.OwnerId = owner.UserId;
             this.Creator = creator;
             this.CreatorId = creator.UserId;
+            this.GDArea = gdArea;
             this.Name = name;
-            this.From = from;
-            this.To = to;
+            this.FinanceBase = financeBase;
+        }
+
+        public static GoalDefinition Default()
+        {
+            return new GoalDefinition();
         }
 
         public Guid Id { get; private set; }
+        public DateTime CreatedAt { get; private set; } = DateTime.Now;
         public DomainUser Owner { get; private set; }
         public Guid OwnerId { get; private set; }
         public DomainUser Creator { get; private set; }
         public Guid CreatorId { get; private set; }
+        public Guid GDAreaId { get; private set; }
+        public GlobalDefinitionArea GDArea { get; private set; }
         public string Name { get; private set; }
-        public DateTime From { get; private set; }
-        public DateTime To { get; private set; }
         public bool OwnerLocked { get; private set; }
         public bool SupervisorLocked { get; private set; }
-        public decimal? Vari { get; private set; }
+        public double? VariProjectHours { get; private set; }
+        public double FinanceBase { get; private set; }
+
 
         private List<GoalItem> _goals = new List<GoalItem>();
         public IReadOnlyList<GoalItem> Goals => _goals.AsReadOnly();
@@ -46,18 +58,30 @@ namespace Leuze.Modules.Goal.Domain.Domains
         {
             this.Name = name;
         }
-        public void SetFrom(DateTime from)
+        public void SetVariProjectHours(double vari)
         {
-            this.From = from;
+            this.VariProjectHours = vari;
         }
-        public void SetTo(DateTime to)
+
+        public void SetFinanceBase(double vari)
         {
-            this.To = to;
+            this.FinanceBase = vari;
         }
-        public void SetVari(decimal vari)
+
+        public void LockByOwner()
+        {
+            this.OwnerLocked = true;
+        }
+
+        public void LockBySupervisor()
         {
-            this.Vari = vari;
+            this.SupervisorLocked = true;
         }
 
+        public void ResetLocks()
+        {
+            this.OwnerLocked = false;
+            this.SupervisorLocked = false;
+        }
     }
 }
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalItem.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalItem.cs
index 8d2c985..ba0d780 100644
--- a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalItem.cs
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalItem.cs
@@ -32,14 +32,17 @@ namespace Leuze.Modules.Goal.Domain.Domains
         }
 
         public Guid Id { get; private set; }
+        public DateTime CreatedAt { get; private set; } = DateTime.Now;
         public GoalDefinition GoalDefinition { get; private set; }
         public Guid GoalDefinitionId { get; private set; }
         public DomainUser Creator { get; private set; }
         public Guid CreatorId { get; private set; }
         public string Name { get; private set; }
         public string Description { get; private set; }
-        public decimal PercentileUser { get; private set; }
-        public decimal PercentileFinal { get; private set; }
+        public double PercentileUser { get; private set; }
+        public double PercentileFinal { get; private set; }
+        public bool OwnerLocked { get; private set; }
+        public bool SupervisorLocked { get; private set; }
 
         private List<Comment> _comments = new();
         public IReadOnlyList<Comment> Comments => _comments.AsReadOnly();
@@ -58,14 +61,29 @@ namespace Leuze.Modules.Goal.Domain.Domains
         {
             this.Description = desc;
         }
-        public void SetPercentileUser(decimal perc)
+        public void SetPercentileUser(double perc)
         {
             this.PercentileUser = perc;
         }
-        public void SetPercentileFinal(decimal perc)
+        public void SetPercentileFinal(double perc)
         {
             this.PercentileFinal = perc;
         }
 
+        public void LockByOwner()
+        {
+            this.OwnerLocked = true;
+        }
+
+        public void LockBySupervisor()
+        {
+            this.SupervisorLocked = true;
+        }
+
+        public void ResetLocks()
+        {
+            this.OwnerLocked = false;
+            this.SupervisorLocked = false;
+        }
     }
 }
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalUpdate.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalUpdate.cs
index ce94a40..377df05 100644
--- a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalUpdate.cs
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalUpdate.cs
@@ -26,7 +26,13 @@ namespace Leuze.Modules.Goal.Domain.Domains
             this.NewValue = newValue;
         }
 
+        public static GoalUpdate Default()
+        {
+            return new GoalUpdate();
+        }
+
         public Guid Id { get; private set; }
+        public DateTime CreatedAt { get; private set; } = DateTime.Now;
         public DomainUser Creator { get; private set; }
         public Guid CreatorId { get; private set; }
         public GoalItem Goal { get; private set; }
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/Review.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/Review.cs
index 86b5776..b545b97 100644
--- a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/Review.cs
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/Review.cs
@@ -26,7 +26,13 @@ namespace Leuze.Modules.Goal.Domain.Domains
             this.IsFinal = isFinal;
         }
 
+        public static Review Default()
+        {
+            return new Review();
+        }
+
         public Guid Id { get; private set; }
+        public DateTime CreatedAt { get; private set; } = DateTime.Now;
         public DomainUser Creator { get; private set; }
         public Guid CreatorId { get; private set; }
         public GoalItem Goal { get; private set; }
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGlobalDefinitionAreaRepository.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGlobalDefinitionAreaRepository.cs
new file mode 100644
index 0000000..8610852
--- /dev/null
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGlobalDefinitionAreaRepository.cs
@@ -0,0 +1,12 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Leuze.Modules.Goal.Domain.Repositories
+{
+    public interface IGlobalDefinitionAreaRepository
+    {
+    }
+}
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGoalDefinitionRepository.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGoalDefinitionRepository.cs
index fd33a06..53d00b2 100644
--- a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGoalDefinitionRepository.cs
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGoalDefinitionRepository.cs
@@ -20,11 +20,9 @@ namespace Leuze.Modules.Goal.Domain.Repositories
 
         Task<bool> RemoveAsync(Guid id);
 
-        Task<bool> SetVariAsync(Guid id, decimal vari);
+        Task<bool> SetVariProjectHoursAsync(Guid id, double vari);
 
-        Task<bool> SetFromAsync(Guid id, DateTime from);
-
-        Task<bool> SetToAsync(Guid id, DateTime to);
+        Task<bool> SetFinanceBaseAsync(Guid id, double financeBase);
 
         Task<bool> SetNameAsync(Guid id, string name);
     }
diff --git a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGoalItemRepository.cs b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGoalItemRepository.cs
index b5decb6..410f5f7 100644
--- a/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGoalItemRepository.cs
+++ b/src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Repositories/IGoalItemRepository.cs
@@ -25,9 +25,9 @@ namespace Leuze.Modules.Goal.Domain.Repositories
 
         Task<bool> SetDescriptionAsync(Guid id, string description);
 
-        Task<bool> SetPercentileUserAsync(Guid id, decimal percentile);
+        Task<bool> SetPercentileUserAsync(Guid id, double percentile);
 
-        Task<bool> SetPercentileFinalAsync(Guid id, decimal percentile);
+        Task<bool> SetPercentileFinalAsync(Guid id, double percentile);
 
         Task<bool> SetGoalDefinitionAsync(Guid id, Guid definitionId);
 
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/DependencyInjection.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/DependencyInjection.cs
index 913a92c..37f6221 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/DependencyInjection.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/DependencyInjection.cs
@@ -55,8 +55,9 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence
                 var context = serviceScope.ServiceProvider.GetRequiredService<LeuzeDbContext>();
                 var appSettings = serviceScope.ServiceProvider.GetRequiredService<IOptions<AppSettings>>().Value;
 
+                //TODO: This is debug delet this
                 var user = context.Set<DomainUser>().Where(item => item.EmailAddress.Email == "ma@test.cz").FirstOrDefault();
-                GoalDefinition gd = new GoalDefinition(user, user, "Test Goal definition", DateTime.Now, DateTime.Now.AddDays(10));
+                GoalDefinition gd = new GoalDefinition(user, user, new GlobalDefinitionArea(user, DateTime.Now, DateTime.Now.AddDays(10)) ,"Test Goal definition");
                 context.Add(gd);
                 context.SaveChanges();
             }
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/CommentRegistrar.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/CommentRegistrar.cs
index aca4b31..6b76cec 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/CommentRegistrar.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/CommentRegistrar.cs
@@ -20,6 +20,7 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Registrars
                 etb.HasOne(e => e.Creator).WithMany().HasForeignKey(e => e.CreatorId);
                 etb.HasOne(e => e.Goal).WithMany(e => e.Comments).HasForeignKey(e => e.GoalId);
                 etb.Property(e => e.Text).IsRequired();
+                etb.Property(e => e.CreatedAt).IsRequired();
 
                 etb.ToTable("Leuze_Modules_Goal_Domain_Comments");
             });
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GlobalDefinitionAreaRegistrar.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GlobalDefinitionAreaRegistrar.cs
new file mode 100644
index 0000000..ee5d117
--- /dev/null
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GlobalDefinitionAreaRegistrar.cs
@@ -0,0 +1,31 @@
+﻿using ExtCore.Data.EntityFramework;
+using Leuze.Modules.Goal.Domain.Domains;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Leuze.Modules.Goal.Infrastructure.Persistence.Registrars
+{
+    public class GlobalDefinitionAreaRegistrar : IEntityRegistrar
+    {
+        public void RegisterEntities(ModelBuilder modelbuilder)
+        {
+            modelbuilder.Entity<GlobalDefinitionArea>(etb =>
+            {
+                etb.HasKey(e => e.Id);
+                etb.Property(e => e.Id).ValueGeneratedOnAdd();
+                etb.HasOne(e => e.Creator).WithMany().HasForeignKey(e => e.CreatorId);
+                etb.Property(e => e.From).IsRequired();
+                etb.Property(e => e.To).IsRequired();
+                etb.Property(e => e.CreatedAt).IsRequired();
+                etb.Property(e => e.VariCompanySuccess).IsRequired(false);
+
+
+                etb.ToTable("Leuze_Modules_Goal_Domain_GoalDefinitionAreas");
+            });
+        }
+    }
+}
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalDefinitionRegistrar.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalDefinitionRegistrar.cs
index 7d80f18..81ee056 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalDefinitionRegistrar.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalDefinitionRegistrar.cs
@@ -19,10 +19,11 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Registrars
                 etb.Property(e => e.Id).ValueGeneratedOnAdd();
                 etb.HasOne(e => e.Creator).WithMany().HasForeignKey(e => e.CreatorId);
                 etb.HasOne(e => e.Owner).WithMany().HasForeignKey(e => e.OwnerId);
+                etb.HasOne(e => e.GDArea).WithMany().HasForeignKey(e => e.GDAreaId);
                 etb.Property(e => e.Name).IsRequired().HasMaxLength(255);
-                etb.Property(e => e.From).IsRequired();
-                etb.Property(e => e.To).IsRequired();
-                etb.Property(e => e.Vari).IsRequired(false);
+                etb.Property(e => e.FinanceBase).IsRequired();
+                etb.Property(e => e.CreatedAt).IsRequired();
+                etb.Property(e => e.VariProjectHours).IsRequired(false);
                 etb.HasMany(e => e.Goals).WithOne(e => e.GoalDefinition).HasForeignKey(e => e.GoalDefinitionId);
 
 
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalRegistrar.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalRegistrar.cs
index ac771df..050e571 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalRegistrar.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalRegistrar.cs
@@ -20,6 +20,7 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Registrars
                 etb.HasOne(e => e.GoalDefinition).WithMany(e => e.Goals).HasForeignKey(e => e.GoalDefinitionId);
                 etb.HasOne(e => e.Creator).WithMany().HasForeignKey(e => e.CreatorId);
                 etb.Property(e => e.Name).IsRequired().HasMaxLength(255);
+                etb.Property(e => e.CreatedAt).IsRequired();
                 etb.HasMany(e => e.Comments).WithOne(e => e.Goal).HasForeignKey(e => e.GoalId);
                 etb.HasMany(e => e.Updates).WithOne(e => e.Goal).HasForeignKey(e => e.GoalId);
                 etb.HasMany(e => e.Reviews).WithOne(e => e.Goal).HasForeignKey(e => e.GoalId);
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalUpdateRegistrar.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalUpdateRegistrar.cs
index f14fdda..8b4510c 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalUpdateRegistrar.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/GoalUpdateRegistrar.cs
@@ -19,6 +19,7 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Registrars
                 etb.Property(e => e.Id).ValueGeneratedOnAdd();
                 etb.HasOne(e => e.Creator).WithMany().HasForeignKey(e => e.CreatorId);
                 etb.HasOne(e => e.Goal).WithMany(e => e.Updates).HasForeignKey(e => e.GoalId);
+                etb.Property(e => e.CreatedAt).IsRequired();
                 etb.Property(e => e.UpdatedType).IsRequired();
                 etb.Property(e => e.OldValue).IsRequired();
                 etb.Property(e => e.NewValue).IsRequired();
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/ReviewRegistrar.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/ReviewRegistrar.cs
index 5bc000b..e9ac460 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/ReviewRegistrar.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Registrars/ReviewRegistrar.cs
@@ -17,6 +17,7 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Registrars
             {
                 etb.HasKey(e => e.Id);
                 etb.Property(e => e.Id).ValueGeneratedOnAdd();
+                etb.Property(e => e.CreatedAt).IsRequired();
                 etb.HasOne(e => e.Creator).WithMany().HasForeignKey(e => e.CreatorId);
                 etb.HasOne(e => e.Goal).WithMany(e => e.Reviews).HasForeignKey(e => e.GoalId);
 
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/CommentRepository.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/CommentRepository.cs
index 2143c69..0d3fe34 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/CommentRepository.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/CommentRepository.cs
@@ -56,7 +56,6 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Repositories
             Comment item = await dbSet.FindAsync(id);
             if (item == null) return false;
             item.SetText(text);
-            item.IsChanged = true;
             await storageContext.SaveChangesAsync();
             return true;
         }
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GlobalDefinitionAreaRepository.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GlobalDefinitionAreaRepository.cs
new file mode 100644
index 0000000..3d3bf3b
--- /dev/null
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GlobalDefinitionAreaRepository.cs
@@ -0,0 +1,13 @@
+﻿using Leuze.Modules.Goal.Domain.Repositories;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Leuze.Modules.Goal.Infrastructure.Persistence.Repositories
+{
+    class GlobalDefinitionAreaRepository : IGlobalDefinitionAreaRepository
+    {
+    }
+}
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalDefinitionRepository.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalDefinitionRepository.cs
index c528206..f231796 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalDefinitionRepository.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalDefinitionRepository.cs
@@ -40,7 +40,7 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Repositories
 
         public async Task<List<GoalDefinition>> GetAllForUserAsync(Guid userId)
         {
-            return await dbSet.Include(item => item.Creator).Where(item => item.OwnerId == userId).ToListAsync();
+            return await dbSet.Include(item => item.Creator).Include(item => item.Goals).Include(item => item.GDArea).Where(item => item.OwnerId == userId).ToListAsync();
         }
 
         public async Task<List<GoalDefinition>> GetAllAsync()
@@ -54,29 +54,20 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Repositories
             return await dbSet.FindAsync(id);
         }
 
-        public async Task<bool> SetVariAsync(Guid id, decimal vari)
+        public async Task<bool> SetVariProjectHoursAsync(Guid id, double variHours)
         {
             GoalDefinition item = await dbSet.FindAsync(id);
             if (item == null) return false;
-            item.SetVari(vari);
+            item.SetVariProjectHours(variHours);
             await storageContext.SaveChangesAsync();
             return true;
         }
 
-        public async Task<bool> SetFromAsync(Guid id, DateTime from)
+        public async Task<bool> SetFinanceBaseAsync(Guid id, double financeBase)
         {
             GoalDefinition item = await dbSet.FindAsync(id);
             if (item == null) return false;
-            item.SetFrom(from);
-            await storageContext.SaveChangesAsync();
-            return true;
-        }
-
-        public async Task<bool> SetToAsync(Guid id, DateTime to)
-        {
-            GoalDefinition item = await dbSet.FindAsync(id);
-            if (item == null) return false;
-            item.SetTo(to);
+            item.SetFinanceBase(financeBase);
             await storageContext.SaveChangesAsync();
             return true;
         }
diff --git a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalItemRepository.cs b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalItemRepository.cs
index 1b3b3f6..564af7b 100644
--- a/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalItemRepository.cs
+++ b/src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalItemRepository.cs
@@ -48,7 +48,7 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Repositories
 
         public async Task<List<GoalItem>> GetAllAsync()
         {
-            return dbSet.ToList(); //TODO: Await??
+            return await dbSet.ToListAsync();
         }
 
         public async Task<bool> SetNameAsync(Guid id, string name)
@@ -69,7 +69,7 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Repositories
             return true;
         }
 
-        public async Task<bool> SetPercentileUserAsync(Guid id, decimal percentile)
+        public async Task<bool> SetPercentileUserAsync(Guid id, double percentile)
         {
             GoalItem item = await dbSet.FindAsync(id);
             if (item == null) return false;
@@ -78,7 +78,7 @@ namespace Leuze.Modules.Goal.Infrastructure.Persistence.Repositories
             return true;
         }
 
-        public async Task<bool> SetPercentileFinalAsync(Guid id, decimal percentile)
+        public async Task<bool> SetPercentileFinalAsync(Guid id, double percentile)
         {
             GoalItem item = await dbSet.FindAsync(id);
             if (item == null) return false;
