Added Added Is Deleted

Added get avail resort

UnivateProperties_API/Containers/Timeshare/RegionDto.cs

-namespace UnivateProperties_API.Containers.Timeshare
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnivateProperties_API.Containers.Timeshare
 {
     public class RegionDto
     {
         public RegionDto()
         {
+            Resorts = new List<ResortDto>();
+        }
 
+        public RegionDto(string regionCode, string regionName)
+        {
+            RegionCode = regionCode;
+            RegionName = regionName;
+            Resorts = new List<ResortDto>();
         }
 
-        public RegionDto(int id, string regionName, string regionCode)
+        public RegionDto(int id, string regionCode, string regionName)
         {
             Id = id;
-            RegionName = regionName;
             RegionCode = regionCode;
+            RegionName = regionName;
+            Resorts = new List<ResortDto>();
         }
 
         public int Id { get; set; }
         public string RegionName { get; set; }
         public string RegionCode { get; set; }
+        public List<ResortDto> Resorts { get; set; }
+
+        public void TryAddResort(string resortCode, string resortName)
+        {
+            if (!Resorts.Any(x => x.ResortCode == resortCode))
+            {
+                Resorts.Add(new ResortDto(resortCode, resortName));
+            }
+        }
     }
 }

UnivateProperties_API/Context/DataContext.cs

 
         public override int SaveChanges()
         {
-            foreach(var item in ChangeTracker
+            foreach (var item in ChangeTracker
                                     .Entries()
                                     .Where(x => x.State == EntityState.Modified || x.State == EntityState.Added)
                                     .Select(x => x.Entity)
                                     .ToList())
             {
-                if(item is BaseEntity)
+                if (item is BaseEntity)
                 {
                     (item as BaseEntity).UpdateModified(string.Empty);
                 }
             }
+            UpdateSoftDeleteStatuses();
             return base.SaveChanges();
         }
 
+        private void UpdateSoftDeleteStatuses()
+        {
+            foreach (var entry in ChangeTracker.Entries())
+            {
+                switch (entry.State)
+                {
+                    case EntityState.Added:
+                        entry.CurrentValues["IsDeleted"] = false;
+                        break;
+                    case EntityState.Deleted:
+                        entry.State = EntityState.Modified;
+                        entry.CurrentValues["IsDeleted"] = true;
+                        break;
+                }
+            }
+        }
+
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             modelBuilder.Entity<SMTPHost>().ToTable("Hosts");
             modelBuilder.Entity<UnitConfiguration>()
                 .HasIndex(u => u.Code)
                 .IsUnique();
+            modelBuilder.Entity<Individual>(b =>
+            {
+                b.HasKey(e => e.Id);
+                b.Property(e => e.Id).ValueGeneratedOnAdd();
+            });
+            modelBuilder.Entity<Agent>(b =>
+            {
+                b.HasKey(e => e.Id);
+                b.Property(e => e.Id).ValueGeneratedOnAdd();
+            });
+            modelBuilder.Entity<Agency>(b =>
+            {
+                b.HasKey(e => e.Id);
+                b.Property(e => e.Id).ValueGeneratedOnAdd();
+            });
+            modelBuilder.Entity<Person>(b =>
+            {
+                b.HasKey(e => e.Id);
+                b.Property(e => e.Id).ValueGeneratedOnAdd();
+            });
+            modelBuilder.Entity<Email>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<SMTPAccount>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<SMTPHost>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Property>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<PropertyImage>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<PropertyType>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<PropertyUserField>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<UserDefinedField>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<UserDefinedGroup>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<City>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Province>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Suburb>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Season>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Status>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<TimeshareWeek>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<UnitConfiguration>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<UnitConfigurationType>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Agency>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Person>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<User>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Bank>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<BankAccount>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<SearchLog>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Address>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<BidItem>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<ProcessFlow>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+
         }
     }
 }

UnivateProperties_API/Controllers/Timeshare/TimeshareWeekController.cs

             return new OkObjectResult(item);
         }
 
+        [HttpGet("getAvailResort")]
+        public IActionResult GetAvailResort()
+        {
+            if (_Repo is WeekRepository)
+            {
+                var item = (_Repo as WeekRepository).GetAvailResort();
+                return new OkObjectResult(item);
+            }
+            else return new OkResult();
+
+        }
+
         [HttpGet("getBy")]
         public IActionResult GetBy(WeekFilterDto week)
         {

UnivateProperties_API/Controllers/Users/AgentController.cs

             using (var scope = new TransactionScope())
             {
                 Agent agent = agentDto.Agent;
-                byte[] passwordHash, passwordSalt;
-                MyCommon.CreatePasswordHash(agentDto.Password, out passwordHash, out passwordSalt);
+                MyCommon.CreatePasswordHash(agentDto.Password, out byte[] passwordHash, out byte[] passwordSalt);
 
                 agent.User.PasswordHash = passwordHash;
                 agent.User.PasswordSalt = passwordSalt;

UnivateProperties_API/Controllers/Users/RegisterController.cs

-using System;
-using System.Collections.Generic;
-using System.IdentityModel.Tokens.Jwt;
-using System.Linq;
-using System.Security.Claims;
-using System.Text;
-using System.Threading.Tasks;
-using AutoMapper;
+using AutoMapper;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Options;
 using Microsoft.IdentityModel.Tokens;
+using System;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
 using UnivateProperties_API.Containers.Users;
 using UnivateProperties_API.Helpers;
 using UnivateProperties_API.Model.Users;
-using UnivateProperties_API.Repository;
 using UnivateProperties_API.Repository.Users;
-using System.Net.Http;
-using System.Net;
-using System.Web.Http;
 
 namespace UnivateProperties_API.Controllers.Users
 {
     public class RegisterController : ControllerBase
     {
         private readonly IRegisterRepository _Repo;
-        private IMapper _mapper;
+        private readonly IMapper _mapper;
         private readonly AppSettings _appSettings;
 
         public RegisterController(IRegisterRepository repo, IMapper mapper, IOptions<AppSettings> appSettings)
                 return BadRequest(new { message = ex.Message });
             }
         }
-
-        //[HttpGet("{id}")]
-        //public IActionResult GetById(int id)
-        //{
-        //    var user = _Repo.GetById(id);
-        //    var userDto = _mapper.Map<UserDto>(user);
-
-        //    if (user == null)
-        //    {
-        //        return NotFound();
-        //    }
-
-        //    // Only allow SuperAdmins to access other user records
-        //    var currentUserId = int.Parse(User.Identity.Name);
-        //    if (id != currentUserId && !User.IsInRole(Role.SuperAdmin))
-        //    {
-        //        return Forbid();
-        //    }
-
-        //    return Ok(userDto);
-        //}
-
-        //[HttpGet("{id}")]
-        //public IActionResult GetByAgencyId(int id)
-        //{
-        //    var agency = _Repo.GetByAgencyId(id);
-        //    var agencyDto = _mapper.Map<AgencyDto>(agency);
-
-        //    if (agency == null)
-        //    {
-        //        return NotFound();
-        //    }
-
-        //    var currentAgencyId = int.Parse(User.Identity.Name);
-        //    if (id != currentAgencyId && !User.IsInRole(Role.Agency))
-        //    {
-        //        return Forbid();
-        //    }
-
-        //    return Ok(agencyDto);
-        //}
-
-        //[Authorize(Roles = Role.SuperAdmin)]
-        //[HttpDelete("{id}")]
-        //public IActionResult Delete(User user)
-        //{
-        //    _Repo.Delete(user.Id);
-        //    return Ok();
-        //}
-
-        //[Authorize(Roles = Role.SuperAdmin)]
-        //[HttpDelete("{id}")]
-        //public IActionResult DeleteAgency(Agency agency)
-        //{
-        //    _Repo.DeleteAgency(agency.Id);
-        //    return Ok();
-        //}
     }
 }

UnivateProperties_API/Migrations/20191003082255_IsDeleted.cs

+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class IsDeleted : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Weeks",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Users",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "UserDefinedGroups",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "UserDefinedFields",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "UnitConfigurationTypes",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "UnitConfigurations",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Suburbs",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Status",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Seasons",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "SearchLogs",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Provinces",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "PropertyUserFields",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "PropertyTypes",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "PropertyImages",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Properties",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "ProcessFlows",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Individuals",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Hosts",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Emails",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Cities",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "BidItems",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Banks",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "BankAccounts",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Agents",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Agencies",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Addresses",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Accounts",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.CreateTable(
+                name: "Person",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
+                    Created = table.Column<DateTime>(nullable: false),
+                    Modified = table.Column<DateTime>(nullable: false),
+                    ModifiedBy = table.Column<string>(nullable: true),
+                    IsDeleted = table.Column<bool>(nullable: false),
+                    UserId = table.Column<int>(nullable: true),
+                    Name = table.Column<string>(nullable: true),
+                    Surname = table.Column<string>(nullable: true),
+                    Email = table.Column<string>(nullable: true),
+                    Telephone = table.Column<string>(nullable: true),
+                    CellNumber = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Person", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Person_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Person_UserId",
+                table: "Person",
+                column: "UserId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Person");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Weeks");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "UserDefinedGroups");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "UserDefinedFields");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "UnitConfigurationTypes");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "UnitConfigurations");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Suburbs");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Status");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Seasons");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "SearchLogs");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Provinces");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "PropertyUserFields");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "PropertyTypes");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "PropertyImages");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Properties");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "ProcessFlows");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Individuals");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Hosts");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Emails");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Cities");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "BidItems");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Banks");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "BankAccounts");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Agents");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Agencies");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Addresses");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Accounts");
+        }
+    }
+}

UnivateProperties_API/Migrations/DataContextModelSnapshot.cs

 #pragma warning disable 612, 618
             modelBuilder
                 .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn)
-                .HasAnnotation("ProductVersion", "2.2.4-servicing-10062")
+                .HasAnnotation("ProductVersion", "2.2.6-servicing-10079")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             modelBuilder.Entity("UnivateProperties_API.Model.Banks.Bank", b =>
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<bool>("IsBodyHtml");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("DisplayName");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Host");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Search");
 
-                    b.Property<int?>("UserID");
+                    b.Property<string>("Type");
 
                     b.HasKey("Id");
 
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("DeclinedReason");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
-                    b.Property<int?>("GCRecord");
+                    b.Property<bool>("IsDeleted");
 
                     b.Property<bool>("IsSale");
 
 
                     b.Property<bool>("IsDefault");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<int>("GroupId");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<DateTime>("DepartureDate");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<bool>("LeviesPaidInFull");
 
                     b.Property<double>("LevyAmount");
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Description");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("EAABEFFCNumber");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("Email");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
 
                     b.Property<string>("IncomeTaxNumber");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<string>("MaritalStatus");
 
                     b.Property<DateTime>("Modified");
                     b.ToTable("Individuals");
                 });
 
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Person", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("CellNumber");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Email");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Surname");
+
+                    b.Property<string>("Telephone");
+
+                    b.Property<int?>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Person");
+                });
+
             modelBuilder.Entity("UnivateProperties_API.Model.Users.User", b =>
                 {
                     b.Property<int>("Id")
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<bool>("IsDeleted");
+
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("ModifiedBy");
                         .WithMany()
                         .HasForeignKey("UserId");
                 });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Person", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Users.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
 #pragma warning restore 612, 618
         }
     }

UnivateProperties_API/Model/BaseEntity.cs

 
 namespace UnivateProperties_API.Model
 {
-    public abstract class BaseEntity
+    public class BaseEntity
     {
         #region Properties
         [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
         public string ModifiedBy { get; set; }
         [NotMapped]
         public ValidateEntity Valid { get; set; }
+        public bool IsDeleted { get; set; } = false;
         #endregion
 
         #region Methods

UnivateProperties_API/Model/Users/User.cs

         {
             Username = username;
 
-            byte[] passwordHash, passwordSalt;
-            MyCommon.CreatePasswordHash(password, out passwordHash, out passwordSalt);
+            MyCommon.CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);
 
             PasswordHash = passwordHash;
             PasswordSalt = passwordSalt;

UnivateProperties_API/Program.cs

         public static IWebHost BuildWebHost(string[] args) =>
             WebHost.CreateDefaultBuilder(args)
                 .UseStartup<Startup>()
-                .UseUrls("http://192.168.6.188/Univate-API")
+                .UseUrls("http://192.168.6.188:5000")
                 .Build();
     }
 }

UnivateProperties_API/Properties/launchSettings.json

       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       },
-      "applicationUrl": "http://localhost:5000"
+      "applicationUrl": "http://192.168.6.188:5000"
     }
   }
 }

UnivateProperties_API/Repository/Banks/BankAccountRepository.cs

 
         public void Insert(Bank item)
         {
+            item.Id = NewBankId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<Bank> items)
         {
+            int id = NewBankId();
             foreach (var item in items)
             {
+                item.Id = id;
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
 
         public void Insert(BankAccount item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<BankAccount> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
+                item.Id = id;
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
         {
             return _dbContext.BankAccounts.ToList();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.BankAccounts.Count() > 0)
+            {
+                _dbContext.BankAccounts.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
+
+        public int NewBankId()
+        {
+            int id = 0;
+            if (_dbContext.Banks.Count() > 0)
+            {
+                _dbContext.Banks.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Communication/EmailRepository.cs

         {
             SMTPAccountRepository account = new SMTPAccountRepository(_dbContext);
             item = GetDetailedObject(item, account);
+            item.Id = NewId();
             item.SendMail();
             _dbContext.Add(item);
             Save();
 
         public void Insert(IEnumerable<Email> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
+                item.Id = id;
                 item.SendMail();
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
         {
             _dbContext.SaveChanges();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Emails.Count() > 0)
+            {
+                id = _dbContext.Emails.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Communication/SMTPAccountRepository.cs

 
         public void Insert(SMTPAccount item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<SMTPAccount> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
+                item.Id = id;
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
         {
             _dbContext.SaveChanges();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Accounts.Count() > 0)
+            {
+                id = _dbContext.Accounts.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Communication/SMTPHostRepository.cs

 
         public void Insert(SMTPHost item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<SMTPHost> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
+                item.Id = id;
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
         {
             _dbContext.SaveChanges();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Hosts.Count() > 0)
+            {
+                id = _dbContext.Hosts.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/IRepository.cs

         void Remove(IEnumerable<TEntity> items);
         void RemoveAtId(int item);
         void Update(TEntity item);
+        int NewId();
         void Save();
     }
 }

UnivateProperties_API/Repository/Logging/SearchLogRepository.cs

             _dbContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            // Not sure if properties need it
+            return 0;
+        }
     }
 }

UnivateProperties_API/Repository/ProccessFlow/BidRepository.cs

             List<BidItem> bids = new List<BidItem>() { bid };
             return LoadDisplay(bids).Find(x => x.Id == bid.Id);
         }
+
+        public int NewId()
+        {
+            // Not sure if properties need it
+            return 0;
+        }
     }
 }

UnivateProperties_API/Repository/Properties/PropertyImageRepository.cs

             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            // Not sure if properties need it
+            return 0;
+        }
     }
 }

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

             }
                 
             return list;
-        }       
+        }
+
+        public int NewId()
+        {
+            // Not sure if properties need it
+            return 0;
+        }
     }
 }

UnivateProperties_API/Repository/Properties/PropertyTypeRepository.cs

             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            // Not sure if properties need it
+            return 0;
+        }
     }
 }

UnivateProperties_API/Repository/Properties/PropertyUserFieldRepository.cs

             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            // Not sure if properties need it
+            return 0;
+        }
     }
 }

UnivateProperties_API/Repository/Properties/UserDefinedFieldRepository.cs

             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            // Not sure if properties need it
+            return 0;
+        }
     }
 }

UnivateProperties_API/Repository/Properties/UserDefinedGroupRepository.cs

             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            // Not sure if properties need it
+            return 0;
+        }
     }
 }

UnivateProperties_API/Repository/Region/CityRepository.cs

 
         public void Insert(City item)
         {
-            dBContext.Cities.Add(item);
+            item.Id = NewId();
+            dBContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<City> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
-                dBContext.Cities.Add(item);
-                Save();
+                item.Id = id;
+                dBContext.Add(item);
+                id += 1;
             }
+            Save();
         }
 
         public void Remove(City item)
             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (dBContext.Cities.Count() > 0)
+            {
+                id = dBContext.Cities.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Region/ProvinceRepository.cs

 
         public void Insert(Province item)
         {
-            dBContext.Provinces.Add(item);
+            item.Id = NewId();
+            dBContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<Province> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
-                dBContext.Provinces.Add(item);
-                Save();
+                item.Id = id;
+                dBContext.Add(item);
+                id += 1;
             }
+            Save();
         }
 
         public void Remove(Province item)
             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (dBContext.Provinces.Count() > 0)
+            {
+                id = dBContext.Provinces.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Region/SuburbRepository.cs

 
         public void Insert(Suburb item)
         {
-            dBContext.Suburbs.Add(item);
+            item.Id = NewId();
+            dBContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<Suburb> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
-                dBContext.Suburbs.Add(item);
-                Save();
+                item.Id = id;
+                dBContext.Add(item);
+                id += 1;
             }
+            Save();
         }
 
         public void Remove(Suburb item)
             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (dBContext.Suburbs.Count() > 0)
+            {
+                id = dBContext.Suburbs.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Timeshare/SeasonRepository.cs

 
         public void Insert(Season item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<Season> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
+                item.Id = id;
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
             _dbContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Seasons.Count() > 0)
+            {
+                id = _dbContext.Seasons.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Timeshare/StatusRepository.cs

 
         public void Insert(Status item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<Status> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
+                item.Id = id;
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
             _dbContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Status.Count() > 0)
+            {
+                id = _dbContext.Status.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Timeshare/UnitConfigurationRepository.cs

 
         public void Insert(UnitConfiguration item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void InsertType(UnitConfigurationType type)
         {
+            int id = _dbContext.UnitConfigurationTypes.Max(x => x.Id);
+            type.Id = id + 1;
             _dbContext.Add(type);
             Save();
         }
 
         public void Insert(IEnumerable<UnitConfiguration> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
+                item.Id = id;
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
             _dbContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.UnitConfigurations.Count() > 0)
+            {
+                id = _dbContext.UnitConfigurations.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Timeshare/WeekRepository.cs

             return list;
         }
 
+        public List<RegionDto> GetAvailResort()
+        {
+            List<RegionDto> list = new List<RegionDto>();
+            foreach (var item in GetDetailedAll())
+            {
+                if (item.Region != null)
+                {
+                    if (!list.Any(x => x.RegionCode == item.Region.Code))
+                    {
+                        list.Add(new RegionDto(item.Region.Code, item.Region.Description));
+                    }
+                    foreach (var i in list.Where(x => x.RegionCode == item.Region.Code))
+                    {
+                        i.TryAddResort(item.ResortCode, item.ResortName);
+                    }
+                }
+
+            }
+            return list;
+        }
+
         public List<TimeshareWeek> GetDetailedAll()
         {
             var list = GetAll();
                 StatusRepository status = new StatusRepository(_dbContext);
                 week.Status = status.Get(x => x.Id == week.StatusId).FirstOrDefault();
             }
+            else
+            {
+                StatusRepository repo = new StatusRepository(_dbContext);
+                week.Status = repo.GetDetailed(s => s.Code == "A1");
+            }
             if (week.RegionId != 0)
             {
                 ProvinceRepository province = new ProvinceRepository(_dbContext);
         public void Insert(TimeshareWeek item)
         {
             item = GetDetailedWeek(item);
-            // Set starting Status of A1
-            StatusRepository repo = new StatusRepository(_dbContext);
-            item.Status = repo.GetDetailed(s => s.Code == "A1");
-            if(item.Status != null)
+            if(item.Status == null)
             {
                 //Create initial
                 item.Status = new Status()
                     StatusType = StatusType.Timeshare,
                     ModifiedBy = "KobusB"
                 };
-            }            
+            }
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<TimeshareWeek> items)
         {
+            int id = NewId();
             foreach (var item in items)
             {
+                item.Id = id;
                 _dbContext.Add(item);
+                id += 1;
             }
             Save();
         }
             }
             return item;
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Weeks.Count() > 0)
+            {
+                id = _dbContext.Weeks.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Users/AgencyRepository.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Model.Users;
 
             return item;
         }
 
-        private Agency GetDetailedObject(Agency item, AgencyRepository repo)
-        {
-            item = repo.GetDetailed(x => x.Id == item.Id);
-            return item;
-        }
-
         public void Insert(Agency item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<Agency> item)
         {
-            _dbContext.Add(item);
+            int id = NewId();
+            foreach (var i in item)
+            {
+                i.Id = id;
+                _dbContext.Add(i);
+                id += 1;
+            }
             Save();
         }
 
             //TODO: GetDetailed Agency
             throw new NotImplementedException();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Agencies.Count() > 0)
+            {
+                id = _dbContext.Agencies.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Users/AgentRepository.cs

 using System.Collections.Generic;
 using System.Linq;
 using UnivateProperties_API.Context;
-using UnivateProperties_API.Helpers;
 using UnivateProperties_API.Model.Users;
 
 namespace UnivateProperties_API.Repository.Users
             return item;
         }
 
-        private Agent GetDetailedObject(Agent item, AgentRepository repo)
-        {
-            item = repo.GetDetailed(x => x.Id == item.Id);
-            return item;
-        }
-
         public void Insert(Agent item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<Agent> item)
         {
+            int id = NewId();
             foreach (var i in item)
             {
-                _dbContext.Add(item);
+                i.Id = id;
+                _dbContext.Add(i);
+                id += 1;
             }
             Save();
         }
             // TODO: GetDetailed
             throw new NotImplementedException();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Agents.Count() > 0)
+            {
+                id = _dbContext.Agents.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Users/IndividualRepository.cs

 
         public void Insert(Individual item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<Individual> item)
         {
-            _dbContext.Add(item);
+            int id = NewId();
+            foreach (var i in item)
+            {
+                i.Id = id;
+                _dbContext.Add(i);
+                id += 1;
+            }
             Save();
         }
 
             // TODO: GetDetailed
             throw new NotImplementedException();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Individuals.Count() > 0)
+            {
+                id = _dbContext.Individuals.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Users/RegisterRepository.cs

 using Microsoft.AspNetCore.Authorization;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Options;
-using Microsoft.IdentityModel.Tokens;
-using System;
 using System.Collections.Generic;
-using System.IdentityModel.Tokens.Jwt;
 using System.Linq;
-using System.Security.Claims;
-using System.Text;
-using UnivateProperties_API.Containers;
 using UnivateProperties_API.Containers.Users;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Helpers;
     {
         private readonly DataContext _dbContext;
 
-        private readonly AppSettings _appSettings;
-
-        public RegisterRepository(DataContext dbContext, IOptions<AppSettings> appSettings)
+        public RegisterRepository(DataContext dbContext)
         {
             _dbContext = dbContext;
-            _appSettings = appSettings.Value;
         }
 
         public User Authenticate(string username, string password)
             if (_dbContext.Users.Any(x => x.Username == user.Username))
                 throw new AppException("Username \"" + user.Username + "\" is already taken");
 
-            byte[] passwordHash, passwordSalt;
-            MyCommon.CreatePasswordHash(password, out passwordHash, out passwordSalt);
+            MyCommon.CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);
 
             user.PasswordHash = passwordHash;
             user.PasswordSalt = passwordSalt;
-
+            user.Id = NewUserId();
             _dbContext.Users.Add(user);
             if (save)
             {
                 EAABEFFCNumber = agency.EaabeffcNumber,
                 CompanyRegNumber = agency.RegNo
             };
-
+            a.Id = NewAgencyId();
             _dbContext.Agencies.Add(a);
             CreatePerson(agency.User, PersonType.Agent, false, a);
 
 
             if (_dbContext.Users.Any(x => x.Username == individual.Username))
                 throw new AppException("Individual \"" + individual.Username + "\" is already taken");
-            byte[] passwordHash, passwordSalt;
 
-            MyCommon.CreatePasswordHash(individual.Password, out passwordHash, out passwordSalt);
+            MyCommon.CreatePasswordHash(individual.Password, out byte[] passwordHash, out byte[] passwordSalt);
 
             User createUser = new User(individual.Username, individual.Password);
 
                     Telephone = individual.Telephone,
                     Agency = agency
                 };
+                agent.Id = NewAgentId();
                 _dbContext.Agents.Add(agent);
             }
             else if (personType == PersonType.Individual)
                     CellNumber = individual.CellNumber,
                     Telephone = individual.Telephone
                 };
+                i.Id = NewIndividualId();
                 _dbContext.Individuals.Add(i);
             }
             if (save)
             }
         }
 
-        //public void InsertPerson(UserDto item)
-        //{
-        //    Individual i = new Individual()
-        //    {
-        //        Name = item.Name,
-        //        Surname = item.Surname,
-        //        User = new User(item.Username, item.Password),
-        //        Email = item.Email,
-        //        CellNumber = item.CellNumber,
-        //        Telephone = item.Telephone
-        //    };
-
-        //    _dbContext.Add(i);
-        //    Save();
-        //}
-
         public void Update(User userParam, string password = null)
         {
             var user = _dbContext.Users.Find(userParam.Id);
             // update password if it was entered
             if (!string.IsNullOrWhiteSpace(password))
             {
-                byte[] passwordHash, passwordSalt;
-                MyCommon.CreatePasswordHash(password, out passwordHash, out passwordSalt);
+                MyCommon.CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);
 
                 user.PasswordHash = passwordHash;
                 user.PasswordSalt = passwordSalt;
         {
             _dbContext.SaveChanges();
         }
+
+        public int NewAgencyId()
+        {
+            int id = 0;
+            if (_dbContext.Agencies.Count() > 0)
+            {
+                id = _dbContext.Agencies.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
+
+        public int NewAgentId()
+        {
+            int id = 0;
+            if (_dbContext.Agents.Count() > 0)
+            {
+                id = _dbContext.Agents.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
+
+        public int NewIndividualId()
+        {
+            int id = 0;
+            if (_dbContext.Individuals.Count() > 0)
+            {
+                id = _dbContext.Individuals.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
+
+        public int NewUserId()
+        {
+            int id = 0;
+            if (_dbContext.Users.Count() > 0)
+            {
+                id = _dbContext.Users.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/Repository/Users/UserRepository.cs

-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Options;
-using Microsoft.IdentityModel.Tokens;
-using System;
+using System;
 using System.Collections.Generic;
-using System.IdentityModel.Tokens.Jwt;
 using System.Linq;
-using System.Security.Claims;
-using System.Text;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Helpers;
 using UnivateProperties_API.Model.Users;
 
         public void Insert(User item)
         {
+            item.Id = NewId();
             _dbContext.Add(item);
             Save();
         }
 
         public void Insert(IEnumerable<User> item)
         {
-            _dbContext.Add(item);
+            int id = NewId();
+            foreach (var i in item)
+            {
+                i.Id = id;
+                _dbContext.Add(i);
+                id += 1;
+            }
             Save();
         }
 
             Save();
         }
 
-        //public void Update(User item)
-        //{
-        //    _dbContext.Entry(item).State = EntityState.Modified;
-        //    Save();
-        //}
-
         public void Update(User userParam)
         {
             var user = _dbContext.Users.Find(userParam.Id);
             // update password if it was entered
             if (!string.IsNullOrWhiteSpace(userParam.PasswordHash.ToString()))
             {
-                byte[] passwordHash, passwordSalt;
-                CreatePasswordHash(userParam.PasswordHash.ToString(), out passwordHash, out passwordSalt);
+                CreatePasswordHash(userParam.PasswordHash.ToString(), out byte[] passwordHash, out byte[] passwordSalt);
 
                 user.PasswordHash = passwordHash;
                 user.PasswordSalt = passwordSalt;
         {
             throw new NotImplementedException();
         }
+
+        public int NewId()
+        {
+            int id = 0;
+            if (_dbContext.Users.Count() > 0)
+            {
+                id = _dbContext.Users.Max(x => x.Id);
+            }
+            id += 1;
+            return id;
+        }
     }
 }

UnivateProperties_API/appsettings.json

   },
   "AllowedHosts": "*",
   "ConnectionStrings": {
-    "DefaultConnection": "Server=localhost;Port=5432;Database=Univate;User Id=postgres;Password=Prov1s1on;"
+    "DefaultConnection": "Server=localhost;Port=5432;Database=Univate;User Id=postgres;Password=prov1s1on;"
   }
 }