fix s.

PSManagement.Application/ApplicationDTOsMappers/MapperConfiguration.cs

@@ -45,7 +45,7 @@ namespace PSManagement.Application.Mappers
 
             CreateMap<TrackDTO, Track>().ReverseMap();
             CreateMap<StepTrack, StepTrackDTO>()
-                .ForMember(d => d.TrackDate, op=> op.MapFrom( src => src.Track.TrackDate));
+                .ForMember(d => d.TrackDate, op=> op.MapFrom( src => src.Track.TrackInfo.TrackDate));
 
             CreateMap<FinancialSpendingDTO, FinancialSpending>().ReverseMap();
            

PSManagement.Application/PSManagement.Application.csproj

@@ -9,16 +9,10 @@
     <Folder Include="Behaviors\AuthorizationBehavior\" />
     <Folder Include="Employees\UseCases\Commands\InreesEmployeeWorkHours\" />
     <Folder Include="Projects\UseCases\Queries\GetProjectAttachments\" />
-    <Folder Include="XReports\UseCases\" />
-    <Folder Include="XReports\UseCases\Queries\" />
-    <Folder Include="Tracks\UseCaes\Commands\CreateTrack\" />
     <Folder Include="Tracks\UseCaes\Commands\AddStepsTrack\" />
-    <Folder Include="Tracks\UseCaes\Commands\AddEmployeesTrack\" />
-    <Folder Include="Tracks\UseCaes\Commands\RemoveTrack\" />
-    <Folder Include="Tracks\UseCaes\Commands\CompleteTrack\" />
     <Folder Include="Tracks\UseCaes\Commands\UpdateEmployeeTrack\" />
     <Folder Include="Tracks\UseCaes\Commands\UpdateStepTrack\" />
-    <Folder Include="Tracks\UseCaes\Commands\UpdateTrack\" />
+    <Folder Include="Tracks\UseCaes\Commands\RemoveTrack\" />
     <Folder Include="Tracks\UseCaes\Queries\GetTrackById\" />
     <Folder Include="Tracks\UseCaes\Queries\GetTracksByProject\" />
     <Folder Include="Tracks\UseCaes\Queries\GetPlanTrack\" />

PSManagement.Application/Tracks/Common/TrackDTO.cs

@@ -10,6 +10,7 @@ namespace PSManagement.Application.Tracks.Common
     public class TrackDTO
     {
         public int Id { get; set; }
+        public bool IsCompleted { get; set; }
         public DateTime TrackDate { get; set; }
         public String TrackNote { get; set; }
         public int ProjectId { get; set; }

PSManagement.Application/Tracks/UseCaes/Commands/AddEmployeesTrack/AddEmployeeTrackCommand.cs

+using Ardalis.Result;
+using PSManagement.Domain.Tracking.ValueObjects;
+using PSManagement.SharedKernel.CQRS.Command;
+using System;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.AddEmployeesTrack
+{
+    public record AddEmployeeTrackCommand(
+    int TrackId,
+    int EmployeeId,
+    EmployeeWorkInfo EmployeeWorkInfo ,
+    EmployeeWork EmployeeWork,
+    String Notes,
+    int ProjectId
+) : ILoggableCommand<Result>;
+}

PSManagement.Application/Tracks/UseCaes/Commands/CompleteTrack/CompleteTrackCommand.cs

+using Ardalis.Result;
+using PSManagement.SharedKernel.CQRS.Command;
+using System;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.CompleteTrack
+{
+    public record CompleteTrackCommand(
+        int TrackId,
+        DateTime TrackDate,
+        int ProjectId
+    ) : ILoggableCommand<Result>;
+}

PSManagement.Application/Tracks/UseCaes/Commands/CompleteTrack/CompleteTrackCommandHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Domain.Steps.Repositories;
+using PSManagement.Domain.Tracking;
+using PSManagement.Domain.Tracking.DomainErrors;
+using PSManagement.Domain.Tracking.DomainEvents;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.Interfaces;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.CompleteTrack
+{
+    public class CompleteTrackCommandHandler : ICommandHandler<CompleteTrackCommand, Result>
+    {
+        private readonly ITracksRepository _tracksRepository;
+        private readonly IUnitOfWork _unitOfWork;
+        
+        public CompleteTrackCommandHandler(
+            
+            IUnitOfWork unitOfWork,
+            ITracksRepository tracksRepository
+            )
+        {
+
+            _unitOfWork = unitOfWork;
+            _tracksRepository = tracksRepository;
+        }
+
+        public async Task<Result> Handle(CompleteTrackCommand request, CancellationToken cancellationToken)
+        {
+            Track track = await _tracksRepository.GetByIdAsync(request.TrackId);
+
+            if (track is null)
+            {
+
+                return Result.Invalid(TracksErrror.InvalidEntryError);
+
+            }
+
+            track.AddDomainEvent(new TrackCompleteddEvent(request.ProjectId, request.TrackId, request.TrackDate));
+
+            await _unitOfWork.SaveChangesAsync();
+
+            return Result.Success();
+
+        }
+    }
+}

PSManagement.Application/Tracks/UseCaes/Commands/CreateTrack/CreateTrackCommand.cs

+using Ardalis.Result;
+using PSManagement.Domain.Projects.ValueObjects;
+using PSManagement.Domain.Tracking.ValueObjects;
+using PSManagement.SharedKernel.CQRS.Command;
+using System;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.CreateTrack
+{
+    public record CreateTrackCommand(
+        TrackInfo TrackInfo,
+        String TrackNote ,
+        int ProjectId 
+    ) : ILoggableCommand<Result<int>>;
+}

PSManagement.Application/Tracks/UseCaes/Commands/CreateTrack/CreateTrackCommandHandler.cs

+using Ardalis.Result;
+using AutoMapper;
+using PSManagement.Domain.Steps.Repositories;
+using PSManagement.Domain.Tracking;
+using PSManagement.Domain.Tracking.DomainEvents;
+using PSManagement.SharedKernel.CQRS.Command;
+using PSManagement.SharedKernel.Interfaces;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PSManagement.Application.Tracks.UseCaes.Commands.CreateTrack
+{
+    public class CreateTrackCommandHandler : ICommandHandler<CreateTrackCommand, Result<int>>
+    {
+        private readonly ITracksRepository _tracksRepository;
+        private readonly IUnitOfWork _unitOfWork;
+        private readonly IMapper _mapper;
+
+        public CreateTrackCommandHandler(
+            IMapper mapper,
+            IUnitOfWork unitOfWork,
+            ITracksRepository tracksRepository
+            )
+        {
+            _mapper = mapper;
+            _unitOfWork = unitOfWork;
+            _tracksRepository = tracksRepository;
+        }
+
+        public async Task<Result<int>> Handle(CreateTrackCommand request, CancellationToken cancellationToken)
+        {
+            Track track = _mapper.Map<Track>(request);
+            track = await _tracksRepository.AddAsync(track);
+            track.AddDomainEvent(new TrackCreatedEvent(request.ProjectId,request.TrackInfo.TrackDate));
+
+            await _unitOfWork.SaveChangesAsync();
+            return Result.Success(track.Id);
+
+        }
+    }
+}

PSManagement.Domain/Employees/Entities/Employee.cs

@@ -4,7 +4,6 @@ using PSManagement.Domain.Tracking;
 using PSManagement.Domain.Tracking.Entities;
 using PSManagement.SharedKernel.Aggregate;
 using PSManagement.SharedKernel.Entities;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -39,8 +38,4 @@ namespace PSManagement.Domain.Employees.Entities
             HIASTId = hiastId;
         }
     }
-    public record WorkInfo (
-        String WorkType , 
-        String WorkJob 
-        );
 }

PSManagement.Domain/Employees/ValueObjects/WorkInfo.cs

+using System;
+
+namespace PSManagement.Domain.Employees.Entities
+{
+    public record WorkInfo (
+        String WorkType , 
+        String WorkJob 
+        );
+}

PSManagement.Domain/PSManagement.Domain.csproj

@@ -6,7 +6,7 @@
 
   <ItemGroup>
     <Folder Include="Identity\ValueObjects\" />
-    <Folder Include="Reports\Repositories\" />
+    <Folder Include="XReports\Repositories\" />
   </ItemGroup>
 
   <ItemGroup>

PSManagement.Domain/Projects/Entities/Project.cs

@@ -2,7 +2,6 @@
 using PSManagement.Domain.Employees.Entities;
 using PSManagement.Domain.FinancialSpends.Entities;
 using PSManagement.Domain.Projects.ValueObjects;
-using PSManagement.Domain.ProjectTypes.Entities;
 using PSManagement.Domain.Tracking;
 using PSManagement.SharedKernel.Aggregate;
 using System;

PSManagement.Domain/XProjectsTypes/Repositories/IProjectTypesRepository.cs → PSManagement.Domain/Tracking/DomainErrors/TracksErrror.cs

-using PSManagement.Domain.ProjectTypes.Entities;
-using PSManagement.SharedKernel.Repositories;
+using PSManagement.SharedKernel.DomainErrors;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace PSManagement.Domain.ProjectTypes.Repositories
+namespace PSManagement.Domain.Tracking.DomainErrors
 {
-    public interface IProjectTypesRepository : IRepository<ProjectType>
+    public class TracksErrror
     {
+        public static DomainError InvalidEntryError { get; } = new("TrackError.InvalidEntry.", "Invalid Project Data");
+
     }
 }

PSManagement.Domain/Tracking/DomainEvents/TrackCompleteddEvent.cs

+using PSManagement.SharedKernel.Events;
+using System;
+
+namespace PSManagement.Domain.Tracking.DomainEvents
+{
+    public record TrackCompleteddEvent(
+        int ProjectId,
+        int TrackId,
+        DateTime Date) : IDomainEvent;
+
+}

PSManagement.Domain/Tracking/DomainEvents/TrackCreatedEvent.cs

+using PSManagement.SharedKernel.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PSManagement.Domain.Tracking.DomainEvents
+{
+    public record  TrackCreatedEvent(
+        int ProjectId,
+        DateTime Date) : IDomainEvent;
+
+}

PSManagement.Domain/Tracking/Entities/EmployeeTrack.cs

 using PSManagement.Domain.Employees.Entities;
+using PSManagement.Domain.Tracking.ValueObjects;
 using PSManagement.SharedKernel.Entities;
-using System;
 
 namespace PSManagement.Domain.Tracking
 {
@@ -10,11 +10,8 @@ namespace PSManagement.Domain.Tracking
         public int TrackId { get; set; }
         public Employee Employee { get; set; }
         public Track Track { get; set; }
-        public int WorkingHours { get; set; }
-        public String PerformedWork { get; set; }
-        public String AssignedWork { get; set; }
-
-        //public ICollection<EmployeeWork> EmployeeWorks { get; set; }
-
+        public EmployeeWorkInfo EmployeeWorkInfo { get; set; }
+        public EmployeeWork EmployeeWork { get; set; }
+        public string Notes { get; set; }
     }
 }

PSManagement.Domain/Tracking/Entities/EmployeeWork.cs

-using PSManagement.Domain.Employees.Entities;
-using PSManagement.SharedKernel.Entities;
-
-namespace PSManagement.Domain.Tracking.Entities
-{
-    public class EmployeeWork : BaseEntity
-    {
-        public int EmployeeWorkId { get; set; }
-        public int StepTrackId { get; set; }
-        public StepTrack StepTrack { get; set; }
-        public int EmployeeId { get; set; }
-        public Employee Employee { get; set; }
-        public int HoursWorked { get; set; }
-        public string Notes { get; set; }
-        public int ContributingRatio { get; set; }
-    }
-}

PSManagement.Domain/Tracking/Entities/StepTrack.cs

@@ -12,9 +12,8 @@ namespace PSManagement.Domain.Tracking.Entities
         public int TrackId { get; set; }
         public Track Track { get; set; }
         public String ExecutionState { get; set; }
-
         public int ExecutionRatio { get; set; }
-        //public ICollection<EmployeeWork> EmployeeWorks { get; set; }
+
         public StepTrack()
         {
                 

PSManagement.Domain/Tracking/Entities/Track.cs

 using PSManagement.Domain.Employees.Entities;
 using PSManagement.Domain.Projects.Entities;
 using PSManagement.Domain.Tracking.Entities;
+using PSManagement.Domain.Tracking.ValueObjects;
 using PSManagement.SharedKernel.Aggregate;
 using PSManagement.SharedKernel.Entities;
 using System;
@@ -13,9 +14,8 @@ namespace PSManagement.Domain.Tracking
 {
     public class Track : BaseEntity
     {
-        public DateTime TrackDate { get; set; }
-        public bool IsCompleted { get; set; }
-        public String TrackNote { get; set; }
+        public TrackInfo TrackInfo { get; set; }
+        public String Notes { get; set; }
         public int ProjectId { get; set; }
         public Project Project { get; set; }
         public ICollection<StepTrack> StepTracks { get; set; }

PSManagement.Domain/Tracking/ValueObjects/EmployeeWork.cs

+namespace PSManagement.Domain.Tracking.ValueObjects
+{
+    public record EmployeeWork(
+        int AssignedWorkingHours,
+        int WorkedHours,
+        int ContributingRatio
+
+    );
+}

PSManagement.Domain/Tracking/ValueObjects/EmployeeWorkInfo.cs

+using System;
+
+namespace PSManagement.Domain.Tracking.ValueObjects
+{
+    public record EmployeeWorkInfo(
+        string AssignedWork,
+         string PerformedWork,
+         DateTime AssignedWorkEnd
+    );
+}

PSManagement.Domain/Tracking/ValueObjects/TrackInfo.cs

+using System;
+
+namespace PSManagement.Domain.Tracking.ValueObjects
+{
+    public record TrackInfo(
+        DateTime TrackDate,
+        bool IsCompleted,
+        string StatusDescription
+        );
+}

PSManagement.Domain/XProjectsTypes/Entities/ProjectType.cs

-using PSManagement.Domain.Projects.Entities;
-using PSManagement.SharedKernel.Aggregate;
-using PSManagement.SharedKernel.Entities;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace PSManagement.Domain.ProjectTypes.Entities
-{
-    public class ProjectType : BaseEntity
-    {
-        public string TypeName { get; set; }
-        public string Description { get; set; }
-        public int WorkerCount { get; set; }
-        public ICollection<Project> Projects { get; set; }
-
-    }
-}

PSManagement.Infrastructure.Persistence/DI/DependencyInjection.cs

@@ -8,11 +8,13 @@ using PSManagement.Domain.FinincialSpending.Repositories;
 using PSManagement.Domain.Identity.Repositories;
 using PSManagement.Domain.Projects.Builders;
 using PSManagement.Domain.Projects.Repositories;
+using PSManagement.Domain.Steps.Repositories;
 using PSManagement.Infrastructure.Persistence.Repositories.Base;
 using PSManagement.Infrastructure.Persistence.Repositories.CustomerRepository;
 using PSManagement.Infrastructure.Persistence.Repositories.EmployeeRepository;
 using PSManagement.Infrastructure.Persistence.Repositories.ProjectRepository;
 using PSManagement.Infrastructure.Persistence.Repositories.StepRepository;
+using PSManagement.Infrastructure.Persistence.Repositories.TrackRepository;
 using PSManagement.Infrastructure.Persistence.Repositories.UserRepository;
 using PSManagement.Infrastructure.Persistence.UoW;
 using PSManagement.SharedKernel.Interfaces;
@@ -36,7 +38,7 @@ namespace PSManagement.Infrastructure.Persistence.DI
             services.AddScoped<IEmployeesRepository, EmployeesRespository>();
             services.AddScoped<IStepsRepository, StepsRepository>();
             services.AddScoped<IFinancialSpendingRepository, FinancialSpendingRepository>();
-
+            services.AddScoped<ITracksRepository, TracksRepository>();             
 
             services.AddScoped<ProjectBuilder>();
             services.AddScoped(typeof(IRepository<>), typeof(BaseRepository<>));

PSManagement.Infrastructure.Persistence/EntitiesConfiguration/TrackEntityConfiguration.cs

@@ -9,10 +9,7 @@ namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
         IEntityTypeConfiguration<Track> , 
         IEntityTypeConfiguration<StepTrack>,
         IEntityTypeConfiguration<EmployeeTrack>
-        //, 
-        //IEntityTypeConfiguration<EmployeeWork>
-
-
+        
     {
         public void Configure(EntityTypeBuilder<Track> builder)
         {
@@ -23,16 +20,15 @@ namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
                 .OnDelete(DeleteBehavior.Restrict);
             builder.Ignore(e => e.TrackedEmployees);
 
-            //builder.HasMany(e => e.TrackedEmployees)
-            //    .WithMany(e => e.trac)
-            //    .UsingEntity<EmployeeParticipate>(
-            //         l => l.HasOne<Employee>(e => e.Employee)
-            //             .WithMany(e => e.EmployeeParticipates)
-            //             .HasForeignKey(e => e.EmployeeId),
-            //         r => r.HasOne<Project>(e => e.Project)
-            //             .WithMany(e => e.EmployeeParticipates)
-            //             .HasForeignKey(e => e.ProjectId)
-            //  );
+            builder.OwnsOne(e => e.TrackInfo, p =>
+            {
+                p.Property(e => e.IsCompleted).HasColumnName("IsCompleted").HasDefaultValue(false);
+                p.Property(e => e.StatusDescription).HasColumnName("StatusDescription");
+
+                p.Property(e => e.TrackDate).HasColumnName("TrackDate");
+
+
+            });
         }
         public void Configure(EntityTypeBuilder<StepTrack> builder)
         {
@@ -56,23 +52,24 @@ namespace PSManagement.Infrastructure.Persistence.EntitiesConfiguration
                 .WithMany(s => s.EmployeeTracks)
                 .HasForeignKey(st => st.EmloyeeId)
             ;
-            
-        }
 
-        //public void Configure(EntityTypeBuilder<EmployeeWork> builder)
-        //{
-        //    //builder.HasOne(ew => ew.StepTrack)
-        //    //.WithMany(st => st.EmployeeWorks)
-        //    //.HasForeignKey(ew => ew.StepTrackId)
-        //    // .OnDelete(DeleteBehavior.Restrict); ;
+            builder.OwnsOne(e => e.EmployeeWorkInfo, p =>
+            {
+                p.Property(e => e.AssignedWork).HasColumnName("AssignedWork");
+                p.Property(e => e.AssignedWorkEnd).HasColumnName("AssignedWorkEnd");
+                p.Property(e => e.PerformedWork).HasColumnName("PerformedWork");
+                
+            });
 
+            builder.OwnsOne(e => e.EmployeeWork, p =>
+            {
+                p.Property(e => e.ContributingRatio).HasColumnName("ContributingRatio");
+                p.Property(e => e.WorkedHours).HasColumnName("WorkedHours");
+                p.Property(e => e.AssignedWorkingHours).HasColumnName("AssignedWorkingHours");
 
-        //    builder.HasOne(ew => ew.Employee)
-        //    .WithMany(e => e.EmployeeWorks)
-        //    .HasForeignKey(ew => ew.EmployeeId)
-        //     .OnDelete(DeleteBehavior.Restrict); ;
+            });
 
+        }
 
-        //}
     }
 }

PSManagement.Infrastructure.Persistence/Migrations/20240816080412_UpdateTrackDomain.Designer.cs

+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using PSManagement.Infrastructure.Persistence;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20240816080412_UpdateTrackDomain")]
+    partial class UpdateTrackDomain
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Relational:Collation", "Arabic_CI_AS")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("ProductVersion", "5.0.17")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CustomerName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Customers");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Department", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Departments");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "قسم المعلوميات"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Name = "قسم النظم الإلكترونية"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Name = "قسم الميكاترونيكس"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Name = "قسم الفيزياء"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Name = "مديرية التطوير والخدمات البرمجية"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Name = "شؤون الطلاب"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("HIASTId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("Employees");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.FinancialSpends.Entities.FinancialSpending", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CostType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ExpectedSpendingDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("LocalPurchase")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("FinancialSpendings");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.Permission", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Permission");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "Admin"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Name = "Employee"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Name = "Scientific-Deputy"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("HashedPassword")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 2,
+                            Email = "Admin@Admin",
+                            HashedPassword = "1234",
+                            UserName = "Admin"
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Attachment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("AttachmentDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AttachmentName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AttachmentUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Attachment");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.EmployeeParticipate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PartialTimeRatio")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("EmployeeParticipate");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CurrentState")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("nvarchar(max)")
+                        .HasDefaultValue("Proposed");
+
+                    b.Property<int?>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExecuterId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProposerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TeamLeaderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ExecuterId");
+
+                    b.HasIndex("ProjectManagerId");
+
+                    b.HasIndex("ProposerId");
+
+                    b.HasIndex("TeamLeaderId");
+
+                    b.ToTable("Projects");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("CurrentCompletionRatio")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Weight")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Steps");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Answer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("AnswerValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("QuestionId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ReportResultId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuestionId");
+
+                    b.HasIndex("ReportResultId");
+
+                    b.ToTable("Answer");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Question", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("QuestionName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Question");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Report", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ReportName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ReportId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ReportResults");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Section", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("ReportId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SectionName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("Section");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.EmployeeTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("EmloyeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TrackId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmloyeeId");
+
+                    b.HasIndex("TrackId");
+
+                    b.ToTable("EmployeeTrack");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("ExecutionRatio")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ExecutionState")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StepId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TrackId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StepId");
+
+                    b.HasIndex("TrackId");
+
+                    b.ToTable("StepTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProjectId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Tracks");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.Property<int>("PermissionsId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RolesId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionsId", "RolesId");
+
+                    b.HasIndex("RolesId");
+
+                    b.ToTable("PermissionRole");
+                });
+
+            modelBuilder.Entity("QuestionSection", b =>
+                {
+                    b.Property<int>("QuestionsId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SectionsId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuestionsId", "SectionsId");
+
+                    b.HasIndex("SectionsId");
+
+                    b.ToTable("QuestionSection");
+                });
+
+            modelBuilder.Entity("UserRole", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RoleId", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserRole");
+
+                    b.HasData(
+                        new
+                        {
+                            RoleId = 1,
+                            UserId = 1
+                        });
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+                {
+                    b.OwnsMany("PSManagement.Domain.Customers.Entities.ContactInfo", "ContactInfo", b1 =>
+                        {
+                            b1.Property<int>("CustomerId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("ContactType")
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.Property<string>("ContactValue")
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.HasKey("CustomerId", "Id");
+
+                            b1.ToTable("ContactInfo");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CustomerId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Customers.ValueObjects.Address", "Address", b1 =>
+                        {
+                            b1.Property<int>("CustomerId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("City")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("City");
+
+                            b1.Property<string>("StreetName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StreetName");
+
+                            b1.Property<int>("StreetNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("StreetNumber");
+
+                            b1.Property<int>("ZipCode")
+                                .HasColumnType("int")
+                                .HasColumnName("ZipCode");
+
+                            b1.HasKey("CustomerId");
+
+                            b1.ToTable("Customers");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CustomerId");
+                        });
+
+                    b.Navigation("Address");
+
+                    b.Navigation("ContactInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.User", "User")
+                        .WithOne("Employee")
+                        .HasForeignKey("PSManagement.Domain.Employees.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Entities.Availability", "Availability", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("CurrentWorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("CurrentWorkingHours");
+
+                            b1.Property<bool>("IsAvailable")
+                                .HasColumnType("bit")
+                                .HasColumnName("IsAvailable");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Entities.PersonalInfo", "PersonalInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("FirstName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FirstName");
+
+                            b1.Property<string>("LastName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("LastName");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Employees.Entities.WorkInfo", "WorkInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("WorkJob")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("WorkJob");
+
+                            b1.Property<string>("WorkType")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("WorkType");
+
+                            b1.HasKey("EmployeeId");
+
+                            b1.ToTable("Employees");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeId");
+                        });
+
+                    b.Navigation("Availability");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("PersonalInfo");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.FinancialSpends.Entities.FinancialSpending", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", null)
+                        .WithMany("FinancialSpending")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.SharedKernel.ValueObjects.Money", "ExternalPurchase", b1 =>
+                        {
+                            b1.Property<int>("FinancialSpendingId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("Ammount")
+                                .HasColumnType("int")
+                                .HasColumnName("ExternalPurchaseAmmount");
+
+                            b1.Property<string>("Currency")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("nvarchar(max)")
+                                .HasDefaultValue("USD")
+                                .HasColumnName("ExternalPurchaseCurrency");
+
+                            b1.HasKey("FinancialSpendingId");
+
+                            b1.ToTable("FinancialSpendings");
+
+                            b1.WithOwner()
+                                .HasForeignKey("FinancialSpendingId");
+                        });
+
+                    b.Navigation("ExternalPurchase");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Attachment", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", null)
+                        .WithMany("Attachments")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.EmployeeParticipate", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "Employee")
+                        .WithMany("EmployeeParticipates")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("EmployeeParticipates")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", null)
+                        .WithMany("Projects")
+                        .HasForeignKey("CustomerId");
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Department", "Executer")
+                        .WithMany()
+                        .HasForeignKey("ExecuterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "ProjectManager")
+                        .WithMany()
+                        .HasForeignKey("ProjectManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PSManagement.Domain.Customers.Entities.Customer", "Proposer")
+                        .WithMany()
+                        .HasForeignKey("ProposerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "TeamLeader")
+                        .WithMany()
+                        .HasForeignKey("TeamLeaderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.Aggreement", "ProjectAggreement", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<DateTime>("AggreementDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("AggreementDate");
+
+                            b1.Property<int>("AggreementNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("AggreementNumber");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.FinancialFund", "FinancialFund", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("FinancialStatus")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FinicialStatus");
+
+                            b1.Property<string>("Source")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("FinicialSource");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.ProjectInfo", "ProjectInfo", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("Code")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Code");
+
+                            b1.Property<string>("Description")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Description");
+
+                            b1.Property<DateTime>("ExpectedEndDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("ExpectedEndDate");
+
+                            b1.Property<string>("Name")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Name");
+
+                            b1.Property<DateTime>("StartDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("StartDate");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.ProposalInfo", "ProposalInfo", b1 =>
+                        {
+                            b1.Property<int>("ProjectId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<DateTime>("ProposingBookDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("ProposingBookDate");
+
+                            b1.Property<int>("ProposingBookNumber")
+                                .HasColumnType("int")
+                                .HasColumnName("ProposingBookNumber");
+
+                            b1.HasKey("ProjectId");
+
+                            b1.ToTable("Projects");
+
+                            b1.WithOwner()
+                                .HasForeignKey("ProjectId");
+                        });
+
+                    b.Navigation("Executer");
+
+                    b.Navigation("FinancialFund");
+
+                    b.Navigation("ProjectAggreement");
+
+                    b.Navigation("ProjectInfo");
+
+                    b.Navigation("ProjectManager");
+
+                    b.Navigation("ProposalInfo");
+
+                    b.Navigation("Proposer");
+
+                    b.Navigation("TeamLeader");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("Steps")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Projects.ValueObjects.StepInfo", "StepInfo", b1 =>
+                        {
+                            b1.Property<int>("StepId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("Description")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("Description");
+
+                            b1.Property<int>("Duration")
+                                .HasColumnType("int")
+                                .HasColumnName("Duration");
+
+                            b1.Property<DateTime>("StartDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("StartDate");
+
+                            b1.Property<string>("StepName")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StepName");
+
+                            b1.HasKey("StepId");
+
+                            b1.ToTable("Steps");
+
+                            b1.WithOwner()
+                                .HasForeignKey("StepId");
+                        });
+
+                    b.Navigation("Project");
+
+                    b.Navigation("StepInfo");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Answer", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Question", "Question")
+                        .WithMany()
+                        .HasForeignKey("QuestionId");
+
+                    b.HasOne("PSManagement.Domain.Reports.Entities.ReportResult", null)
+                        .WithMany("Answers")
+                        .HasForeignKey("ReportResultId");
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Section", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Report", "Report")
+                        .WithMany("Sections")
+                        .HasForeignKey("ReportId");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.EmployeeTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Employees.Entities.Employee", "Employee")
+                        .WithMany("EmployeeTracks")
+                        .HasForeignKey("EmloyeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Tracking.Track", "Track")
+                        .WithMany("EmployeeTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.EmployeeWork", "EmployeeWork", b1 =>
+                        {
+                            b1.Property<int>("EmployeeTrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("AssignedWorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("AssignedWorkingHours");
+
+                            b1.Property<int>("ContributingRatio")
+                                .HasColumnType("int")
+                                .HasColumnName("ContributingRatio");
+
+                            b1.Property<int>("WorkedHours")
+                                .HasColumnType("int")
+                                .HasColumnName("WorkedHours");
+
+                            b1.HasKey("EmployeeTrackId");
+
+                            b1.ToTable("EmployeeTrack");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeTrackId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.EmployeeWorkInfo", "EmployeeWorkInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeTrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("AssignedWork")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("AssignedWork");
+
+                            b1.Property<DateTime>("AssignedWorkEnd")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("AssignedWorkEnd");
+
+                            b1.Property<string>("PerformedWork")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("PerformedWork");
+
+                            b1.HasKey("EmployeeTrackId");
+
+                            b1.ToTable("EmployeeTrack");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeTrackId");
+                        });
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("EmployeeWork");
+
+                    b.Navigation("EmployeeWorkInfo");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Entities.StepTrack", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Step", "Step")
+                        .WithMany("StepTracks")
+                        .HasForeignKey("StepId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Tracking.Track", "Track")
+                        .WithMany("StepTracks")
+                        .HasForeignKey("TrackId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Step");
+
+                    b.Navigation("Track");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Projects.Entities.Project", "Project")
+                        .WithMany("Tracks")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.TrackInfo", "TrackInfo", b1 =>
+                        {
+                            b1.Property<int>("TrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<bool>("IsCompleted")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("bit")
+                                .HasDefaultValue(false)
+                                .HasColumnName("IsCompleted");
+
+                            b1.Property<string>("StatusDescription")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StatusDescription");
+
+                            b1.Property<DateTime>("TrackDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("TrackDate");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
+                    b.Navigation("Project");
+
+                    b.Navigation("TrackInfo");
+                });
+
+            modelBuilder.Entity("PermissionRole", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Permission", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RolesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("QuestionSection", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Question", null)
+                        .WithMany()
+                        .HasForeignKey("QuestionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Reports.Entities.Section", null)
+                        .WithMany()
+                        .HasForeignKey("SectionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("UserRole", b =>
+                {
+                    b.HasOne("PSManagement.Domain.Identity.Entities.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PSManagement.Domain.Identity.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Customers.Entities.Customer", b =>
+                {
+                    b.Navigation("Projects");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Employees.Entities.Employee", b =>
+                {
+                    b.Navigation("EmployeeParticipates");
+
+                    b.Navigation("EmployeeTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Identity.Entities.User", b =>
+                {
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Project", b =>
+                {
+                    b.Navigation("Attachments");
+
+                    b.Navigation("EmployeeParticipates");
+
+                    b.Navigation("FinancialSpending");
+
+                    b.Navigation("Steps");
+
+                    b.Navigation("Tracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Projects.Entities.Step", b =>
+                {
+                    b.Navigation("StepTracks");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.Report", b =>
+                {
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Reports.Entities.ReportResult", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("PSManagement.Domain.Tracking.Track", b =>
+                {
+                    b.Navigation("EmployeeTracks");
+
+                    b.Navigation("StepTracks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/20240816080412_UpdateTrackDomain.cs

+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace PSManagement.Infrastructure.Persistence.Migrations
+{
+    public partial class UpdateTrackDomain : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "WorkingHours",
+                table: "EmployeeTrack");
+
+            migrationBuilder.RenameColumn(
+                name: "TrackNote",
+                table: "Tracks",
+                newName: "StatusDescription");
+
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "TrackDate",
+                table: "Tracks",
+                type: "datetime2",
+                nullable: true,
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2");
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "IsCompleted",
+                table: "Tracks",
+                type: "bit",
+                nullable: true,
+                defaultValue: false,
+                oldClrType: typeof(bool),
+                oldType: "bit");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Notes",
+                table: "Tracks",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ExecutionState",
+                table: "StepTracks",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "AssignedWorkEnd",
+                table: "EmployeeTrack",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "AssignedWorkingHours",
+                table: "EmployeeTrack",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "ContributingRatio",
+                table: "EmployeeTrack",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Notes",
+                table: "EmployeeTrack",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "WorkedHours",
+                table: "EmployeeTrack",
+                type: "int",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Notes",
+                table: "Tracks");
+
+            migrationBuilder.DropColumn(
+                name: "ExecutionState",
+                table: "StepTracks");
+
+            migrationBuilder.DropColumn(
+                name: "AssignedWorkEnd",
+                table: "EmployeeTrack");
+
+            migrationBuilder.DropColumn(
+                name: "AssignedWorkingHours",
+                table: "EmployeeTrack");
+
+            migrationBuilder.DropColumn(
+                name: "ContributingRatio",
+                table: "EmployeeTrack");
+
+            migrationBuilder.DropColumn(
+                name: "Notes",
+                table: "EmployeeTrack");
+
+            migrationBuilder.DropColumn(
+                name: "WorkedHours",
+                table: "EmployeeTrack");
+
+            migrationBuilder.RenameColumn(
+                name: "StatusDescription",
+                table: "Tracks",
+                newName: "TrackNote");
+
+            migrationBuilder.AlterColumn<DateTime>(
+                name: "TrackDate",
+                table: "Tracks",
+                type: "datetime2",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified),
+                oldClrType: typeof(DateTime),
+                oldType: "datetime2",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<bool>(
+                name: "IsCompleted",
+                table: "Tracks",
+                type: "bit",
+                nullable: false,
+                defaultValue: false,
+                oldClrType: typeof(bool),
+                oldType: "bit",
+                oldNullable: true,
+                oldDefaultValue: false);
+
+            migrationBuilder.AddColumn<int>(
+                name: "WorkingHours",
+                table: "EmployeeTrack",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+        }
+    }
+}

PSManagement.Infrastructure.Persistence/Migrations/AppDbContextModelSnapshot.cs

@@ -435,21 +435,15 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                         .HasColumnType("int")
                         .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
-                    b.Property<string>("AssignedWork")
-                        .HasColumnType("nvarchar(max)");
-
                     b.Property<int>("EmloyeeId")
                         .HasColumnType("int");
 
-                    b.Property<string>("PerformedWork")
+                    b.Property<string>("Notes")
                         .HasColumnType("nvarchar(max)");
 
                     b.Property<int>("TrackId")
                         .HasColumnType("int");
 
-                    b.Property<int>("WorkingHours")
-                        .HasColumnType("int");
-
                     b.HasKey("Id");
 
                     b.HasIndex("EmloyeeId");
@@ -469,6 +463,9 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                     b.Property<int>("ExecutionRatio")
                         .HasColumnType("int");
 
+                    b.Property<string>("ExecutionState")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<int>("StepId")
                         .HasColumnType("int");
 
@@ -491,18 +488,12 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                         .HasColumnType("int")
                         .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
-                    b.Property<bool>("IsCompleted")
-                        .HasColumnType("bit");
+                    b.Property<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
 
                     b.Property<int>("ProjectId")
                         .HasColumnType("int");
 
-                    b.Property<DateTime>("TrackDate")
-                        .HasColumnType("datetime2");
-
-                    b.Property<string>("TrackNote")
-                        .HasColumnType("nvarchar(max)");
-
                     b.HasKey("Id");
 
                     b.HasIndex("ProjectId");
@@ -1019,8 +1010,66 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.EmployeeWork", "EmployeeWork", b1 =>
+                        {
+                            b1.Property<int>("EmployeeTrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<int>("AssignedWorkingHours")
+                                .HasColumnType("int")
+                                .HasColumnName("AssignedWorkingHours");
+
+                            b1.Property<int>("ContributingRatio")
+                                .HasColumnType("int")
+                                .HasColumnName("ContributingRatio");
+
+                            b1.Property<int>("WorkedHours")
+                                .HasColumnType("int")
+                                .HasColumnName("WorkedHours");
+
+                            b1.HasKey("EmployeeTrackId");
+
+                            b1.ToTable("EmployeeTrack");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeTrackId");
+                        });
+
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.EmployeeWorkInfo", "EmployeeWorkInfo", b1 =>
+                        {
+                            b1.Property<int>("EmployeeTrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<string>("AssignedWork")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("AssignedWork");
+
+                            b1.Property<DateTime>("AssignedWorkEnd")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("AssignedWorkEnd");
+
+                            b1.Property<string>("PerformedWork")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("PerformedWork");
+
+                            b1.HasKey("EmployeeTrackId");
+
+                            b1.ToTable("EmployeeTrack");
+
+                            b1.WithOwner()
+                                .HasForeignKey("EmployeeTrackId");
+                        });
+
                     b.Navigation("Employee");
 
+                    b.Navigation("EmployeeWork");
+
+                    b.Navigation("EmployeeWorkInfo");
+
                     b.Navigation("Track");
                 });
 
@@ -1051,7 +1100,38 @@ namespace PSManagement.Infrastructure.Persistence.Migrations
                         .OnDelete(DeleteBehavior.Restrict)
                         .IsRequired();
 
+                    b.OwnsOne("PSManagement.Domain.Tracking.ValueObjects.TrackInfo", "TrackInfo", b1 =>
+                        {
+                            b1.Property<int>("TrackId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                            b1.Property<bool>("IsCompleted")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("bit")
+                                .HasDefaultValue(false)
+                                .HasColumnName("IsCompleted");
+
+                            b1.Property<string>("StatusDescription")
+                                .HasColumnType("nvarchar(max)")
+                                .HasColumnName("StatusDescription");
+
+                            b1.Property<DateTime>("TrackDate")
+                                .HasColumnType("datetime2")
+                                .HasColumnName("TrackDate");
+
+                            b1.HasKey("TrackId");
+
+                            b1.ToTable("Tracks");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TrackId");
+                        });
+
                     b.Navigation("Project");
+
+                    b.Navigation("TrackInfo");
                 });
 
             modelBuilder.Entity("PermissionRole", b =>

PSManagement.Infrastructure.Persistence/Repositories/EmployeeRepository/EmployeesRespository.cs

 using PSManagement.Domain.Employees.Entities;
 using PSManagement.Domain.Employees.Repositories;
+using PSManagement.Domain.FinincialSpending.Repositories;
 using PSManagement.Infrastructure.Persistence.Repositories.Base;
 
 namespace PSManagement.Infrastructure.Persistence.Repositories.EmployeeRepository
@@ -10,4 +11,5 @@ namespace PSManagement.Infrastructure.Persistence.Repositories.EmployeeRepositor
         {
         }
     }
+
 }

PSManagement.Infrastructure.Persistence/Repositories/TrackRepository/TracksRepository.cs

+using PSManagement.Domain.Steps.Repositories;
+using PSManagement.Domain.Tracking;
+using PSManagement.Infrastructure.Persistence.Repositories.Base;
+
+namespace PSManagement.Infrastructure.Persistence.Repositories.TrackRepository
+{
+    public class TracksRepository : BaseRepository<Track>, ITracksRepository
+    {
+        public TracksRepository(AppDbContext context) : base(context)
+        {
+        }
+    }
+
+}