Check in of API

.gitattributes

@@ -0,0 +1,63 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs     diff=csharp
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following 
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln       merge=binary
+#*.csproj    merge=binary
+#*.vbproj    merge=binary
+#*.vcxproj   merge=binary
+#*.vcproj    merge=binary
+#*.dbproj    merge=binary
+#*.fsproj    merge=binary
+#*.lsproj    merge=binary
+#*.wixproj   merge=binary
+#*.modelproj merge=binary
+#*.sqlproj   merge=binary
+#*.wwaproj   merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg   binary
+#*.png   binary
+#*.gif   binary
+
+###############################################################################
+# diff behavior for common document formats
+# 
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the 
+# entries below.
+###############################################################################
+#*.doc   diff=astextplain
+#*.DOC   diff=astextplain
+#*.docx  diff=astextplain
+#*.DOCX  diff=astextplain
+#*.dot   diff=astextplain
+#*.DOT   diff=astextplain
+#*.pdf   diff=astextplain
+#*.PDF   diff=astextplain
+#*.rtf   diff=astextplain
+#*.RTF   diff=astextplain

.gitignore

@@ -0,0 +1,340 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!?*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+*- Backup*.rdl
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush personal settings
+.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+# Local History for Visual Studio
+.localhistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb

UnivateProperties_API.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29009.5
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnivateProperties_API", "UnivateProperties_API\UnivateProperties_API.csproj", "{EF248AE7-5D65-4894-AAD9-C6296270F03B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{EF248AE7-5D65-4894-AAD9-C6296270F03B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EF248AE7-5D65-4894-AAD9-C6296270F03B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EF248AE7-5D65-4894-AAD9-C6296270F03B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EF248AE7-5D65-4894-AAD9-C6296270F03B}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {925AD3C6-1FC6-40AC-92DD-ED0B244B9177}
+	EndGlobalSection
+EndGlobal

UnivateProperties_API/Containers/Property/Group.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace UnivateProperties_API.Containers.Property
+{
+    public class Group
+    {
+        #region Properties
+        public string Name { get; set; }
+        public List<GroupFields> Fields { get; set; }
+        #endregion
+    }
+}

UnivateProperties_API/Containers/Property/GroupFields.cs

@@ -0,0 +1,11 @@
+namespace UnivateProperties_API.Containers.Property
+{
+    public class GroupFields
+    {
+        #region Properties
+        public int ID { get; set; }
+        public string Name { get; set; }
+        public string Type { get; set; }
+        #endregion
+    }
+}

UnivateProperties_API/Containers/Property/PropertyDetail.cs

@@ -0,0 +1,11 @@
+namespace UnivateProperties_API.Containers.Property
+{
+    public class PropertyDetail
+    {
+        #region Properties
+        public string Name { get; set; }
+        public string Value { get; set; }
+        public string Description { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Containers/Property/PropertyDetailGroup.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace UnivateProperties_API.Containers.Property
+{
+    public class PropertyDetailGroup
+    {
+        #region Properties
+        public string GroupName { get; set; }
+        public List<PropertyDetail> Values { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Containers/Property/PropertyDisplay.cs

@@ -0,0 +1,43 @@
+namespace UnivateProperties_API.Containers.Property
+{
+    public class PropertyDisplay
+    {
+        #region Properties
+        public int Id { get; set; }
+        public string ShortDescription { get; set; }
+        public bool IsSale { get; set; }
+        public string DisplayPrice { get; set; }
+        public string Area { get; set; }
+        public string Beds { get; set; }
+        public string Baths { get; set; }
+        public string Garages { get; set; }
+        public bool ShowFooter
+        {
+            get
+            {
+                bool showFooter = true;
+
+                if (string.IsNullOrEmpty(Area) && string.IsNullOrEmpty(Beds) && string.IsNullOrEmpty(Baths) && string.IsNullOrEmpty(Garages))
+                    showFooter = false;
+
+                return showFooter;
+            }
+        }
+        public string Province { get; set; }
+        public string City { get; set; }
+        public string Suburb { get; set; }
+        public string DisplayImage { get; set; }
+        #endregion 
+    }
+
+    public class PropertySearch
+    {
+        #region Properties
+        public string Type { get; set; }
+        public string PropertyType { get; set; }
+        public string Province { get; set; }
+        public string City { get; set; }
+        public string Suburb { get; set; }
+        #endregion
+    }
+}

UnivateProperties_API/Containers/Timeshare/UnitConfigurationDto.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace UnivateProperties_API.Containers.Timeshare
+{
+    public class UnitConfigurationDto
+    {
+        public int Id { get; set; }
+        public string Code { get; set; }
+        public int Bedrooms { get; set; }
+        public int Adults { get; set; }
+        public int Children { get; set; }
+        public List<string> Types { get; set; }
+    }
+}

UnivateProperties_API/Containers/Users/AgencyDto.cs

@@ -0,0 +1,11 @@
+namespace UnivateProperties_API.Containers.Users
+{
+    public class AgencyDto
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string EaabeffcNumber { get; set; }
+        public string RegNo { get; set; }
+        public UserDto User { get; set; }
+    }
+}

UnivateProperties_API/Containers/Users/Role.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace UnivateProperties_API.Containers.Users
+{
+    public class Role
+    {
+        public const string SuperAdmin = "Super Admin";
+        public const string PrivateUser = "Private User";
+        public const string Agency = "Agency";
+        public const string Agent = "Agent";
+        public const string ManagingAgent = "Managing Agent";
+        public const string Developer = "Developer";
+    }
+}

UnivateProperties_API/Containers/Users/UserDto.cs

@@ -0,0 +1,15 @@
+namespace UnivateProperties_API.Containers.Users
+{
+    public class UserDto
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Surname { get; set; }
+        public int AgencyId { get; set; }
+        public string Username { get; set; }
+        public string Password { get; set; }
+        public string Email { get; set; }
+        public string Telephone { get; set; }
+        public string CellNumber { get; set; }
+    }
+}

UnivateProperties_API/Containers/ValidateEntity.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnivateProperties_API.Containers
+{
+    public class ValidateEntity
+    {
+        public ValidateEntity()
+        {
+            Errors = new List<string>();
+        }
+
+        public ValidationResult Result
+        {
+            get
+            {
+                return (Errors == null || Errors.Count() == 0) ? ValidationResult.Success : ValidationResult.Failed;
+            }
+        }
+
+        public string ResultString
+        {
+            get
+            {
+                string message = string.Empty;
+                foreach(var item in Errors)
+                {
+                    message += $"{item} {Environment.NewLine}";
+                }
+                return message;
+            }
+        }
+
+        public List<string> Errors { get; set; }
+    }
+}

UnivateProperties_API/Context/DataContext.cs

@@ -0,0 +1,79 @@
+using Microsoft.EntityFrameworkCore;
+using UnivateProperties_API.Model.Communication;
+using UnivateProperties_API.Model.Users;
+using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Region;
+using UnivateProperties_API.Model.Timeshare;
+using System.Linq;
+using UnivateProperties_API.Model;
+
+namespace UnivateProperties_API.Context
+{
+    public class DataContext : DbContext
+    {
+        public DataContext(DbContextOptions<DataContext> options) : base(options)
+        {
+
+        }
+
+        #region User
+        public virtual DbSet<Agency> Agencies { get; set; }
+        public virtual DbSet<Agent> Agents { get; set; }
+        public virtual DbSet<User> Users { get; set; }
+        public virtual DbSet<Individual> Individuals { get; set; }
+        #endregion User
+
+        #region Communication
+        public virtual DbSet<Email> Emails { get; set; }
+        public virtual DbSet<SMTPAccount> Accounts { get; set; }
+        public virtual DbSet<SMTPHost> Hosts { get; set; }
+        #endregion Communication
+
+        #region Property
+        public DbSet<Property> Properties { get; set; }
+        public DbSet<PropertyImage> PropertyImages { get; set; }
+        public DbSet<PropertyType> PropertyTypes { get; set; }
+        public DbSet<PropertyUserField> PropertyUserFields { get; set; }
+        public DbSet<UserDefinedField> UserDefinedFields { get; set; }
+        public DbSet<UserDefinedGroup> UserDefinedGroups { get; set; }
+        #endregion
+
+        #region Region 
+        public DbSet<Province> Provinces { get; set; }
+        public DbSet<City> Cities { get; set; }
+        public DbSet<Suburb> Suburbs { get; set; }
+        #endregion
+
+        #region Timeshare
+        public DbSet<TimeshareWeek> Weeks { get; set; }
+        public DbSet<Status> Status { get; set; }
+        public DbSet<UnitConfiguration> UnitConfigurations { get; set; }
+        public DbSet<UnitConfigurationType> UnitConfigurationTypes { get; set; }
+        public DbSet<Season> Seasons { get; set; }
+        #endregion Timeshare
+
+        public override int SaveChanges()
+        {
+            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)
+                {
+                    (item as BaseEntity).UpdateModified(string.Empty);
+                }
+            }
+            return base.SaveChanges();
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<SMTPHost>().ToTable("Hosts");
+            modelBuilder.Entity<UnitConfiguration>()
+                .HasIndex(u => u.Code)
+                .IsUnique();
+        }
+    }
+}

UnivateProperties_API/Controllers/Communication/AccountController.cs

@@ -0,0 +1,66 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Communication;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Communication
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class AccountController : ControllerBase
+    {
+        private readonly IRepository<SMTPAccount> _Repo;
+
+        public AccountController(IRepository<SMTPAccount> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var items = _Repo.GetAll();
+            return new OkObjectResult(items);
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            var item = _Repo.Get(x => x.Id == id);
+            return new OkObjectResult(item);
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] SMTPAccount item)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(item);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = item.Id }, item);
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult Put([FromBody] SMTPAccount item)
+        {
+            if (item != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(item);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Communication/EmailController.cs

@@ -0,0 +1,66 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Communication;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Communication
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class EmailController : ControllerBase
+    {
+        private readonly IRepository<Email> _Repo;
+
+        public EmailController(IRepository<Email> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var items = _Repo.GetAll();
+            return new OkObjectResult(items);
+        }
+
+        [HttpGet("{id}", Name = "Get")]
+        public IActionResult Get(int id)
+        {
+            var item = _Repo.Get(x => x.Id == id);
+            return new OkObjectResult(item);
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] Email item)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(item);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = item.Id }, item);
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult Put([FromBody] Email item)
+        {
+            if (item != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(item);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Communication/HostController.cs

@@ -0,0 +1,66 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Communication;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Communication
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class HostController : ControllerBase
+    {
+        private readonly IRepository<SMTPHost> _Repo;
+
+        public HostController(IRepository<SMTPHost> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var items = _Repo.GetAll();
+            return new OkObjectResult(items);
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            var item = _Repo.Get(x => x.Id == id);
+            return new OkObjectResult(item);
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] SMTPHost item)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(item);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = item.Id }, item);
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult Put([FromBody] SMTPHost item)
+        {
+            if (item != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(item);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Properties/PropertyController.cs

@@ -0,0 +1,79 @@
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Transactions;
+using UnivateProperties_API.Containers.Property;
+using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Repository.Properties;
+
+namespace UnivateProperties_API.Controllers.Properties
+{
+    [Route("Property/[controller]")]
+    [ApiController]
+    public class PropertyController : ControllerBase
+    {
+        private readonly IPropertyRepository _Repo;
+
+        public PropertyController(IPropertyRepository repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetDisplay());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
+        }
+
+        [HttpGet("search/{type}/{keyword}")]
+        public IActionResult Get(string type, string Keyword)
+        {
+            return new OkObjectResult(_Repo.GetDisplay(Keyword));
+        }
+
+        [HttpGet("search/{type}/{propertytype}/{province}/{city}/{suburb}/{proptype}")]
+        public IActionResult Get(string type, string propertyType, string province, string city, string suburb, string propType)
+        {
+            return new OkObjectResult(_Repo.GetDisplay(type, propertyType, province, city, suburb, propType));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] Property property)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(property);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = property.Id }, property);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] Property property)
+        {
+            if (property != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(property);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}
+

UnivateProperties_API/Controllers/Properties/PropertyFieldsController.cs

@@ -0,0 +1,38 @@
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Repository.Properties;
+
+namespace UnivateProperties_API.Controllers.Properties
+{
+    [Route("Property/[controller]")]
+    [ApiController]
+    public class PropertyFieldsController : ControllerBase
+    {
+        private readonly IUserDefinedGroupRepository _Repo;
+
+        public PropertyFieldsController(IUserDefinedGroupRepository repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetFieldList(""));
+        }
+
+        [HttpGet("{name}")]
+        public IActionResult Get(string name)
+        {
+            return new OkObjectResult(_Repo.GetFieldList(name));
+        }
+
+        [HttpGet("{PropertyType}/{type}")]
+        public IActionResult Get(string PropertyType, string type)
+        {
+            return new OkObjectResult(_Repo.GetFieldListByPropType(type));
+        }
+    }
+
+
+}
+

UnivateProperties_API/Controllers/Properties/PropertyImageController.cs

@@ -0,0 +1,71 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Repository.Properties;
+
+namespace UnivateProperties_API.Controllers.Properties
+{
+    [Route("Property/[controller]")]
+    [ApiController]
+    public class PropertyImageController : ControllerBase
+    {
+        private readonly IPropertyImageRepository _Repo;
+
+        public PropertyImageController(IPropertyImageRepository repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
+        }
+
+        [HttpGet("{Property}/{PropertyId}", Name = "GetImagesByProperty")]
+        public IActionResult Get(string Property, int PropertyId) //Property string is more of a placeholder here.
+        {
+            return new OkObjectResult(_Repo.GetImages(PropertyId));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] PropertyImage propertyImage)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(propertyImage);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = propertyImage.Id }, propertyImage);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] PropertyImage propertyImage)
+        {
+            if (propertyImage != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(propertyImage);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}
+

UnivateProperties_API/Controllers/Properties/PropertyTypeController.cs

@@ -0,0 +1,83 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Properties
+{
+    [Route("Property/[controller]")]
+    [ApiController]
+    public class PropertyTypeController : ControllerBase
+    {
+        private readonly IRepository<PropertyType> _Repo;
+
+        public PropertyTypeController(IRepository<PropertyType> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
+        }
+
+        [HttpGet("{type}/{typename}")]
+        public IActionResult Get(string Type, string TypeName)
+        {
+
+            PropertyUsageType type = PropertyUsageType.Both;
+            switch (TypeName.ToUpper())
+            {
+                case "RESIDENTIAL":
+                    type = PropertyUsageType.Residential;
+                    break;
+                case "COMMERCIAL":
+                    type = PropertyUsageType.Commercial;
+                    break;
+            }
+
+            return new OkObjectResult(_Repo.Get(x => x.UsageType == type || x.UsageType == PropertyUsageType.Both));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] PropertyType propertyType)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(propertyType);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = propertyType.Id }, propertyType);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] PropertyType propertyType)
+        {
+            if (propertyType != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(propertyType);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}
+

UnivateProperties_API/Controllers/Properties/PropertyUserFieldController.cs

@@ -0,0 +1,65 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Properties
+{
+    [Route("Property/[controller]")]
+    [ApiController]
+    public class PropertyUserFieldController : ControllerBase
+    {
+        private readonly IRepository<PropertyUserField> _Repo;
+
+        public PropertyUserFieldController(IRepository<PropertyUserField> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] PropertyUserField propertyUserField)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(propertyUserField);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = propertyUserField.Id }, propertyUserField);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] PropertyUserField propertyUserField)
+        {
+            if (propertyUserField != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(propertyUserField);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}
+

UnivateProperties_API/Controllers/Properties/UserDefinedFieldController.cs

@@ -0,0 +1,71 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Properties
+{
+    [Route("Property/[controller]")]
+    [ApiController]
+    public class UserDefinedFieldController : ControllerBase
+    {
+        private readonly IRepository<UserDefinedField> _Repo;
+
+        public UserDefinedFieldController(IRepository<UserDefinedField> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
+        }
+
+        [HttpGet("{group}/{id}")]
+        public IActionResult Get(string group, int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.GroupId == id));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] UserDefinedField userDefinedField)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(userDefinedField);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = userDefinedField.Id }, userDefinedField);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] UserDefinedField userDefinedField)
+        {
+            if (userDefinedField != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(userDefinedField);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}
+

UnivateProperties_API/Controllers/Properties/UserDefinedGroupController.cs

@@ -0,0 +1,65 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Repository.Properties;
+
+namespace UnivateProperties_API.Controllers.Properties
+{
+    [Route("Property/[controller]")]
+    [ApiController]
+    public class UserDefinedGroupController : ControllerBase
+    {
+        private readonly IUserDefinedGroupRepository _Repo;
+
+        public UserDefinedGroupController(IUserDefinedGroupRepository repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] UserDefinedGroup userDefinedGroup)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(userDefinedGroup);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = userDefinedGroup.Id }, userDefinedGroup);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] UserDefinedGroup userDefinedGroup)
+        {
+            if (userDefinedGroup != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(userDefinedGroup);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}
+

UnivateProperties_API/Controllers/Region/CityController.cs

@@ -0,0 +1,71 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Region;
+using UnivateProperties_API.Repository.Region;
+
+namespace UnivateProperties_API.Controllers.Region
+{
+    [Route("Region/[controller]")]
+    [ApiController]
+    public class CityController : ControllerBase
+    {
+        private readonly ICityRepository _Repo;
+
+        public CityController(ICityRepository repo)
+        {
+            _Repo = repo;
+        }
+
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.Id == id));
+        }
+
+        [HttpGet("getby/{value}")]
+        public IActionResult Get(string value)
+        {
+            return new OkObjectResult(_Repo.GetBy(value));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] City city)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(city);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = city.Id }, city);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] City city)
+        {
+            if (city != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(city);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Region/ProvinceController.cs

@@ -0,0 +1,64 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Region;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Region
+{
+    [Route("Region/[controller]")]
+    [ApiController]
+    public class ProvinceController : ControllerBase
+    {
+        private readonly IRepository<Province> _Repo;
+
+        public ProvinceController(IRepository<Province> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.Id == id));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] Province province)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(province);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = province.Id }, province);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] Province province)
+        {
+            if (province != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(province);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Region/SuburbController.cs

@@ -0,0 +1,70 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Region;
+using UnivateProperties_API.Repository.Region;
+
+namespace UnivateProperties_API.Controllers.Region
+{
+    [Route("Region/[controller]")]
+    [ApiController]
+    public class SuburbController : ControllerBase
+    {
+        private readonly ISuburbRepository _Repo;
+
+        public SuburbController(ISuburbRepository repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.Id == id));
+        }
+
+        [HttpGet("{province}/{city}")]
+        public IActionResult Get(string Province, string City)
+        {
+            return new OkObjectResult(_Repo.GetBy(Province, City));
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] Suburb suburb)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(suburb);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = suburb.Id }, suburb);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] Suburb suburb)
+        {
+            if (suburb != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(suburb);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Timeshare/SeasonController.cs

@@ -0,0 +1,66 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Timeshare
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class SeasonController : ControllerBase
+    {
+        private readonly IRepository<Season> _Repo;
+
+        public SeasonController(IRepository<Season> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var items = _Repo.GetAll();
+            return new OkObjectResult(items);
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            var item = _Repo.Get(x => x.Id == id);
+            return new OkObjectResult(item);
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] Season item)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(item);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = item.Id }, item);
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult Put([FromBody] Season item)
+        {
+            if (item != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(item);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Timeshare/StatusController.cs

@@ -0,0 +1,66 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Timeshare
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class StatusController : ControllerBase
+    {
+        private readonly IRepository<Status> _Repo;
+
+        public StatusController(IRepository<Status> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var items = _Repo.GetAll();
+            return new OkObjectResult(items);
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            var item = _Repo.Get(x => x.Id == id);
+            return new OkObjectResult(item);
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] Status item)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(item);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = item.Id }, item);
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult Put([FromBody] Status item)
+        {
+            if (item != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(item);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Timeshare/TimeshareWeekController.cs

@@ -0,0 +1,66 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Timeshare
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class TimeshareWeekController : ControllerBase
+    {
+        private readonly IRepository<TimeshareWeek> _Repo;
+
+        public TimeshareWeekController(IRepository<TimeshareWeek> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var items = _Repo.GetAll();
+            return new OkObjectResult(items);
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            var item = _Repo.Get(x => x.Id == id);
+            return new OkObjectResult(item);
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] TimeshareWeek item)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(item);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = item.Id }, item);
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult Put([FromBody] TimeshareWeek item)
+        {
+            if (item != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(item);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Timeshare/UnitConfigurationController.cs

@@ -0,0 +1,67 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Repository;
+using UnivateProperties_API.Repository.Timeshare;
+
+namespace UnivateProperties_API.Controllers.Timeshare
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class UnitConfigurationController : ControllerBase
+    {
+        private readonly IRepository<UnitConfiguration> _Repo;
+
+        public UnitConfigurationController(IRepository<UnitConfiguration> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            var items = (_Repo as UnitConfigurationRepository).GetMyDetailed();
+            return new OkObjectResult(items);
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            var item = _Repo.Get(x => x.Id == id);
+            return new OkObjectResult(item);
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] UnitConfiguration item)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(item);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = item.Id }, item);
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult Put([FromBody] UnitConfiguration item)
+        {
+            if (item != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(item);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Users/AgencyController.cs

@@ -0,0 +1,65 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Users;
+using UnivateProperties_API.Repository;
+using UnivateProperties_API.Repository.Users;
+
+namespace User_API.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class AgencyController : ControllerBase
+    {
+        private readonly IRepository<Agency> _Repo;
+
+        public AgencyController(IRepository<Agency> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.Id == id));
+        }
+
+        [HttpPost()]
+        public IActionResult Post([FromBody] Agency agency)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(agency);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = agency.Id }, agency);
+            }
+        }
+
+        [HttpPut()]
+        public IActionResult Put([FromBody] Agency agency)
+        {
+            if (agency != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(agency);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Users/AgentController.cs

@@ -0,0 +1,65 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Users;
+using UnivateProperties_API.Repository;
+using UnivateProperties_API.Repository.Users;
+
+namespace User_API.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class AgentController : ControllerBase
+    {
+        private readonly IRepository<Agent> _Repo;
+
+        public AgentController(IRepository<Agent> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.Id == id));
+        }
+
+        [HttpPost()]
+        public IActionResult Post([FromBody] Agent agent)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(agent);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = agent.Id }, agent);
+            }
+        }
+
+        [HttpPut()]
+        public IActionResult Put([FromBody] Agent agent)
+        {
+            if (agent != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(agent);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Users/IndividualController.cs

@@ -0,0 +1,65 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Users;
+using UnivateProperties_API.Repository;
+using UnivateProperties_API.Repository.Users;
+
+namespace User_API.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class IndividualController : ControllerBase
+    {
+        private readonly IRepository<Individual> _Repo;
+
+        public IndividualController(IRepository<Individual> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.Id == id));
+        }
+
+        [HttpPost()]
+        public IActionResult Post([FromBody] Individual individual)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(individual);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = individual.Id }, individual);
+            }
+        }
+
+        [HttpPut()]
+        public IActionResult Put([FromBody] Individual individual)
+        {
+            if (individual != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(individual);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Controllers/Users/RegisterController.cs

@@ -0,0 +1,208 @@
+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 Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+using UnivateProperties_API.Containers.Users;
+using UnivateProperties_API.Helpers;
+using UnivateProperties_API.Model.Users;
+using UnivateProperties_API.Repository;
+using UnivateProperties_API.Repository.Users;
+
+namespace UnivateProperties_API.Controllers.Users
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class RegisterController : ControllerBase
+    {
+        private readonly IRegisterRepository _Repo;
+        private IMapper _mapper;
+        private readonly AppSettings _appSettings;
+
+        public RegisterController(IRegisterRepository repo, IMapper mapper, IOptions<AppSettings> appSettings)
+        {
+            _Repo = repo;
+            _mapper = mapper;
+            _appSettings = appSettings.Value;
+        }
+
+        [AllowAnonymous]
+        [HttpPost("authenticate")]
+        public IActionResult Authenticate([FromBody]UserDto userDto)
+        {
+            var user = _Repo.Authenticate(userDto.Username, userDto.Password);
+
+            if (user == null)
+                return BadRequest(new { message = "Username or password is incorrect" });
+
+            var tokenHandler = new JwtSecurityTokenHandler();
+            var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
+            var tokenDescriptor = new SecurityTokenDescriptor
+            {
+                Subject = new ClaimsIdentity(new Claim[]
+                {
+                    new Claim(ClaimTypes.Name, user.Id.ToString()),
+                    new Claim(ClaimTypes.Role, user.Role)
+                }),
+                Expires = DateTime.UtcNow.AddMinutes(15),
+                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
+            };
+            var token = tokenHandler.CreateToken(tokenDescriptor);
+            var tokenString = tokenHandler.WriteToken(token);
+
+            // return basic user info (without password) and token to store client side
+            return Ok(new
+            {
+                user.Id,
+                user.Username,
+                user.Name,
+                user.Surname,
+                Token = tokenString
+            });
+        }
+
+        [AllowAnonymous]
+        [HttpPost("register")]
+        public IActionResult Register([FromBody]UserDto userDto)
+        {
+            // map dto to entity
+            var user = _mapper.Map<User>(userDto);
+
+            try
+            {
+                // save 
+                _Repo.Create(user, userDto.Password, true);
+                return Ok();
+            }
+            catch (AppException ex)
+            {
+                // return error message if there was an exception
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [AllowAnonymous]
+        [HttpPost("registeragency")]
+        public IActionResult RegisterAgency([FromBody]AgencyDto agency)
+        {
+            // map dto to entity
+            _mapper.Map<Agency>(agency);
+
+            try
+            {
+                // save 
+                _Repo.CreateAgency(agency);
+                return Ok();
+            }
+            catch (AppException ex)
+            {
+                // return error message if there was an exception
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult Update(int id, [FromBody]UserDto userDto)
+        {
+            // map dto to entity and set id
+            var user = _mapper.Map<User>(userDto);
+            user.Id = id;
+
+            try
+            {
+                // save 
+                _Repo.Update(user, userDto.Password);
+                return Ok();
+            }
+            catch (AppException ex)
+            {
+                // return error message if there was an exception
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [HttpPut("{id}")]
+        public IActionResult UpdateAgency(int id, [FromBody]UserDto userDto)
+        {
+            // map dto to entity and set id
+            var agency = _mapper.Map<Agency>(userDto);
+            agency.Id = id;
+
+            try
+            {
+                // save 
+                _Repo.UpdateAgency(agency, userDto.Password);
+                return Ok();
+            }
+            catch (AppException ex)
+            {
+                // return error message if there was an exception
+                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/Controllers/Users/UserController.cs

@@ -0,0 +1,67 @@
+using System.Transactions;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Users;
+using UnivateProperties_API.Repository;
+using UnivateProperties_API.Repository.Users;
+
+namespace User_API.Controllers
+{
+    [Authorize]
+    [Route("api/[controller]")]
+    [ApiController]
+    public class UserController : ControllerBase
+    {
+        private readonly IRepository<User> _Repo;
+
+        public UserController(IRepository<User> repo)
+        {
+            _Repo = repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.Id == id));
+        }
+
+        [HttpPost()]
+        public IActionResult Post([FromBody] User user)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(user);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = user.Id }, user);
+            }
+        }
+
+        [HttpPut()]
+        public IActionResult Put([FromBody] User user)
+        {
+            if (user != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(user);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {
+            _Repo.RemoveAtId(id);
+            return new OkResult();
+        }
+    }
+}

UnivateProperties_API/Enums.cs

@@ -0,0 +1,21 @@
+namespace UnivateProperties_API
+{
+    public enum PropertyUsageType
+    {
+        Residential,
+        Commercial,
+        Both
+    }
+
+    public enum ValidationResult
+    {
+        Success,
+        Failed
+    }
+
+    public enum PersonType
+    {
+        Individual,
+        Agent
+    }
+}

UnivateProperties_API/Helpers/AppException.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace UnivateProperties_API.Helpers
+{
+    public class AppException : Exception
+    {
+        public AppException() : base()
+        {
+        }
+
+        public AppException(string message) : base(message)
+        {
+        }
+
+        public AppException(string message, params object[] args)
+            : base(String.Format(CultureInfo.CurrentCulture, message, args))
+        {
+        }
+    }
+}

UnivateProperties_API/Helpers/AutoMapperProfile.cs

@@ -0,0 +1,17 @@
+using AutoMapper;
+using UnivateProperties_API.Containers.Users;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Helpers
+{
+    public class AutoMapperProfile : Profile
+    {
+        public AutoMapperProfile()
+        {
+            CreateMap<User, UserDto>();
+            CreateMap<UserDto, User>();
+            CreateMap<Agency, AgencyDto>();
+            CreateMap<AgencyDto, Agency>();
+        }
+    }
+}

UnivateProperties_API/Helpers/MyCommon.cs

@@ -0,0 +1,18 @@
+using System.Text.RegularExpressions;
+
+namespace UnivateProperties_API.Helpers
+{
+    public static class MyCommon
+    {
+        public static bool IsValidEmail(string item)
+        {
+            if (!string.IsNullOrEmpty(item))
+            {
+                Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
+                Match match = regex.Match(item);
+                return match.Success;
+            }
+            else return false;
+        }
+    }
+}

UnivateProperties_API/Migrations/20190828083244_1124.Designer.cs

@@ -0,0 +1,767 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using UnivateProperties_API.Context;
+
+namespace UnivateProperties_API.Migrations
+{
+    [DbContext(typeof(DataContext))]
+    [Migration("20190828083244_1124")]
+    partial class _1124
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn)
+                .HasAnnotation("ProductVersion", "2.2.4-servicing-10062")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.Email", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("BCC");
+
+                    b.Property<string>("Body");
+
+                    b.Property<string>("CC");
+
+                    b.Property<string>("Comment");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsBodyHtml");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("SenderId");
+
+                    b.Property<string>("Subject");
+
+                    b.Property<string>("To");
+
+                    b.Property<string>("ToDisplay");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SenderId");
+
+                    b.ToTable("Emails");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.SMTPAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Address");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("DisplayName");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("SMTPHostId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SMTPHostId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.SMTPHost", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Host");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<bool>("NeedsAuthorize");
+
+                    b.Property<string>("Password");
+
+                    b.Property<bool>("UseSSL");
+
+                    b.Property<string>("User");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Hosts");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.Property", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AddressLine1");
+
+                    b.Property<string>("AddressLine2");
+
+                    b.Property<string>("AddressLine3");
+
+                    b.Property<int>("CityId");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsSale");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<decimal>("OperationalCosts");
+
+                    b.Property<decimal>("Price");
+
+                    b.Property<string>("PricePer");
+
+                    b.Property<string>("PropertyName");
+
+                    b.Property<int>("PropertyTypeId");
+
+                    b.Property<int>("ProvinceId");
+
+                    b.Property<string>("ShortDescription");
+
+                    b.Property<int>("SuburbId");
+
+                    b.Property<string>("Unit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CityId");
+
+                    b.HasIndex("PropertyTypeId");
+
+                    b.HasIndex("ProvinceId");
+
+                    b.HasIndex("SuburbId");
+
+                    b.ToTable("Properties");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyImage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Image");
+
+                    b.Property<bool>("IsDefault");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("PropertyId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PropertyId");
+
+                    b.ToTable("PropertyImages");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("UsageType");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyTypes");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyUserField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("PropertyId");
+
+                    b.Property<int>("UserDefinedFieldId");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PropertyId");
+
+                    b.HasIndex("UserDefinedFieldId");
+
+                    b.ToTable("PropertyUserFields");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.UserDefinedField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("FieldName");
+
+                    b.Property<string>("FieldType");
+
+                    b.Property<int>("GroupId");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("Rank");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("UserDefinedFields");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.UserDefinedGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("Rank");
+
+                    b.Property<int>("UsageType");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("UserDefinedGroups");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.City", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Code");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("ProvinceId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProvinceId");
+
+                    b.ToTable("Cities");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.Province", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Code");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Provinces");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.Suburb", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("CityId");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("PostalCode");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CityId");
+
+                    b.ToTable("Suburbs");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.Season", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Seasons");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.Status", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Code");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Status");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.TimeshareWeek", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AgencyId");
+
+                    b.Property<int>("AgentId");
+
+                    b.Property<DateTime>("ArrivalDate");
+
+                    b.Property<string>("BankedWith");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("CurrentYearBanked");
+
+                    b.Property<DateTime>("DepartureDate");
+
+                    b.Property<bool>("LeviesPaidInFull");
+
+                    b.Property<double>("LevyAmount");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Module");
+
+                    b.Property<DateTime>("OriginalPurchaseDate");
+
+                    b.Property<double>("OriginalPurchasePrice");
+
+                    b.Property<bool>("OtherResort");
+
+                    b.Property<bool>("ReferedByAgent");
+
+                    b.Property<int>("RegionId");
+
+                    b.Property<string>("ResortCode");
+
+                    b.Property<string>("ResortName");
+
+                    b.Property<string>("Season");
+
+                    b.Property<int>("StatusId");
+
+                    b.Property<int>("UnitConfigurationId");
+
+                    b.Property<string>("WeekNumber");
+
+                    b.Property<bool>("WeekPlacedForRental");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AgencyId");
+
+                    b.HasIndex("AgentId");
+
+                    b.HasIndex("RegionId");
+
+                    b.HasIndex("StatusId");
+
+                    b.HasIndex("UnitConfigurationId");
+
+                    b.ToTable("Weeks");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.UnitConfiguration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Adults");
+
+                    b.Property<int>("Bedrooms");
+
+                    b.Property<int>("Children");
+
+                    b.Property<string>("Code");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("UnitConfigurations");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.UnitConfigurationType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("UnitConfigurationId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UnitConfigurationId");
+
+                    b.ToTable("UnitConfigurationTypes");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Agency", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AgencyName");
+
+                    b.Property<string>("CompanyRegNumber");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("EAABEFFCNumber");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Agencies");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Agent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("AgencyId");
+
+                    b.Property<string>("CellNumber");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Email");
+
+                    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("AgencyId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Agents");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Individual", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("CellNumber");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Email");
+
+                    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("Individuals");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.Property<byte[]>("PasswordHash");
+
+                    b.Property<byte[]>("PasswordSalt");
+
+                    b.Property<string>("Role");
+
+                    b.Property<string>("Surname");
+
+                    b.Property<string>("Token");
+
+                    b.Property<string>("Username");
+
+                    b.Property<bool>("Verified");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.Email", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Communication.SMTPAccount", "Sender")
+                        .WithMany("Emails")
+                        .HasForeignKey("SenderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.SMTPAccount", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Communication.SMTPHost", "SMTPHost")
+                        .WithMany("SMTPAccounts")
+                        .HasForeignKey("SMTPHostId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.Property", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Region.City", "City")
+                        .WithMany()
+                        .HasForeignKey("CityId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Property.PropertyType", "PropertyType")
+                        .WithMany()
+                        .HasForeignKey("PropertyTypeId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Region.Province", "Province")
+                        .WithMany()
+                        .HasForeignKey("ProvinceId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Region.Suburb", "Suburb")
+                        .WithMany()
+                        .HasForeignKey("SuburbId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyImage", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Property.Property", "Property")
+                        .WithMany("PropertyImages")
+                        .HasForeignKey("PropertyId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyUserField", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Property.Property", "Property")
+                        .WithMany("PropertyUserFields")
+                        .HasForeignKey("PropertyId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Property.UserDefinedField", "UserDefinedField")
+                        .WithMany()
+                        .HasForeignKey("UserDefinedFieldId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.UserDefinedField", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Property.UserDefinedGroup", "Group")
+                        .WithMany("Fields")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.City", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Region.Province", "Province")
+                        .WithMany()
+                        .HasForeignKey("ProvinceId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.Suburb", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Region.City", "City")
+                        .WithMany()
+                        .HasForeignKey("CityId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.TimeshareWeek", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Users.Agency", "Agency")
+                        .WithMany()
+                        .HasForeignKey("AgencyId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Users.Agent", "Agent")
+                        .WithMany()
+                        .HasForeignKey("AgentId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Region.Province", "Region")
+                        .WithMany()
+                        .HasForeignKey("RegionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Timeshare.Status", "Status")
+                        .WithMany()
+                        .HasForeignKey("StatusId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Timeshare.UnitConfiguration", "UnitConfiguration")
+                        .WithMany()
+                        .HasForeignKey("UnitConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.UnitConfigurationType", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Timeshare.UnitConfiguration", "UnitConfiguration")
+                        .WithMany("Types")
+                        .HasForeignKey("UnitConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Agent", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Users.Agency", "Agency")
+                        .WithMany("Agents")
+                        .HasForeignKey("AgencyId");
+
+                    b.HasOne("UnivateProperties_API.Model.Users.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Individual", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Users.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

UnivateProperties_API/Migrations/20190828083244_1124.cs

@@ -0,0 +1,740 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class _1124 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Agencies",
+                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),
+                    AgencyName = table.Column<string>(nullable: true),
+                    EAABEFFCNumber = table.Column<string>(nullable: true),
+                    CompanyRegNumber = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Agencies", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Hosts",
+                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),
+                    Host = table.Column<string>(nullable: true),
+                    NeedsAuthorize = table.Column<bool>(nullable: false),
+                    User = table.Column<string>(nullable: true),
+                    Password = table.Column<string>(nullable: true),
+                    UseSSL = table.Column<bool>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Hosts", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "PropertyTypes",
+                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),
+                    Description = table.Column<string>(nullable: true),
+                    UsageType = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PropertyTypes", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Provinces",
+                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),
+                    Description = table.Column<string>(nullable: true),
+                    Code = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Provinces", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Seasons",
+                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),
+                    Name = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Seasons", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Status",
+                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),
+                    Code = table.Column<string>(nullable: true),
+                    Description = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Status", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "UnitConfigurations",
+                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),
+                    Code = table.Column<string>(nullable: true),
+                    Bedrooms = table.Column<int>(nullable: false),
+                    Adults = table.Column<int>(nullable: false),
+                    Children = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UnitConfigurations", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "UserDefinedGroups",
+                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),
+                    Description = table.Column<string>(nullable: true),
+                    UsageType = table.Column<int>(nullable: false),
+                    Rank = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserDefinedGroups", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Users",
+                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),
+                    Name = table.Column<string>(nullable: true),
+                    Surname = table.Column<string>(nullable: true),
+                    Username = table.Column<string>(nullable: true),
+                    Role = table.Column<string>(nullable: true),
+                    PasswordHash = table.Column<byte[]>(nullable: true),
+                    PasswordSalt = table.Column<byte[]>(nullable: true),
+                    Verified = table.Column<bool>(nullable: false),
+                    Token = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Users", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Accounts",
+                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),
+                    Address = table.Column<string>(nullable: true),
+                    DisplayName = table.Column<string>(nullable: true),
+                    SMTPHostId = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Accounts", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Accounts_Hosts_SMTPHostId",
+                        column: x => x.SMTPHostId,
+                        principalTable: "Hosts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Cities",
+                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),
+                    ProvinceId = table.Column<int>(nullable: false),
+                    Description = table.Column<string>(nullable: true),
+                    Code = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Cities", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Cities_Provinces_ProvinceId",
+                        column: x => x.ProvinceId,
+                        principalTable: "Provinces",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "UnitConfigurationTypes",
+                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),
+                    Description = table.Column<string>(nullable: true),
+                    UnitConfigurationId = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UnitConfigurationTypes", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_UnitConfigurationTypes_UnitConfigurations_UnitConfiguration~",
+                        column: x => x.UnitConfigurationId,
+                        principalTable: "UnitConfigurations",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "UserDefinedFields",
+                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),
+                    GroupId = table.Column<int>(nullable: false),
+                    FieldName = table.Column<string>(nullable: true),
+                    FieldType = table.Column<string>(nullable: true),
+                    Rank = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserDefinedFields", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_UserDefinedFields_UserDefinedGroups_GroupId",
+                        column: x => x.GroupId,
+                        principalTable: "UserDefinedGroups",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Agents",
+                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),
+                    UserId = table.Column<int>(nullable: false),
+                    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),
+                    AgencyId = table.Column<int>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Agents", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Agents_Agencies_AgencyId",
+                        column: x => x.AgencyId,
+                        principalTable: "Agencies",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_Agents_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Individuals",
+                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),
+                    UserId = table.Column<int>(nullable: false),
+                    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_Individuals", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Individuals_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Emails",
+                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),
+                    SenderId = table.Column<int>(nullable: false),
+                    Comment = table.Column<string>(nullable: true),
+                    Subject = table.Column<string>(nullable: true),
+                    IsBodyHtml = table.Column<bool>(nullable: false),
+                    CC = table.Column<string>(nullable: true),
+                    BCC = table.Column<string>(nullable: true),
+                    Body = table.Column<string>(nullable: true),
+                    To = table.Column<string>(nullable: true),
+                    ToDisplay = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Emails", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Emails_Accounts_SenderId",
+                        column: x => x.SenderId,
+                        principalTable: "Accounts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Suburbs",
+                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),
+                    CityId = table.Column<int>(nullable: false),
+                    Description = table.Column<string>(nullable: true),
+                    PostalCode = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Suburbs", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Suburbs_Cities_CityId",
+                        column: x => x.CityId,
+                        principalTable: "Cities",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Weeks",
+                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),
+                    ReferedByAgent = table.Column<bool>(nullable: false),
+                    AgentId = table.Column<int>(nullable: false),
+                    AgencyId = table.Column<int>(nullable: false),
+                    UnitConfigurationId = table.Column<int>(nullable: false),
+                    OtherResort = table.Column<bool>(nullable: false),
+                    ResortCode = table.Column<string>(nullable: true),
+                    ResortName = table.Column<string>(nullable: true),
+                    RegionId = table.Column<int>(nullable: false),
+                    Season = table.Column<string>(nullable: true),
+                    Module = table.Column<string>(nullable: true),
+                    WeekNumber = table.Column<string>(nullable: true),
+                    LevyAmount = table.Column<double>(nullable: false),
+                    CurrentYearBanked = table.Column<bool>(nullable: false),
+                    BankedWith = table.Column<string>(nullable: true),
+                    LeviesPaidInFull = table.Column<bool>(nullable: false),
+                    WeekPlacedForRental = table.Column<bool>(nullable: false),
+                    OriginalPurchasePrice = table.Column<double>(nullable: false),
+                    OriginalPurchaseDate = table.Column<DateTime>(nullable: false),
+                    ArrivalDate = table.Column<DateTime>(nullable: false),
+                    DepartureDate = table.Column<DateTime>(nullable: false),
+                    StatusId = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Weeks", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Weeks_Agencies_AgencyId",
+                        column: x => x.AgencyId,
+                        principalTable: "Agencies",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Weeks_Agents_AgentId",
+                        column: x => x.AgentId,
+                        principalTable: "Agents",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Weeks_Provinces_RegionId",
+                        column: x => x.RegionId,
+                        principalTable: "Provinces",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Weeks_Status_StatusId",
+                        column: x => x.StatusId,
+                        principalTable: "Status",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Weeks_UnitConfigurations_UnitConfigurationId",
+                        column: x => x.UnitConfigurationId,
+                        principalTable: "UnitConfigurations",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Properties",
+                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),
+                    PropertyTypeId = table.Column<int>(nullable: false),
+                    PropertyName = table.Column<string>(nullable: true),
+                    Unit = table.Column<string>(nullable: true),
+                    OperationalCosts = table.Column<decimal>(nullable: false),
+                    Price = table.Column<decimal>(nullable: false),
+                    PricePer = table.Column<string>(nullable: true),
+                    IsSale = table.Column<bool>(nullable: false),
+                    Description = table.Column<string>(nullable: true),
+                    ShortDescription = table.Column<string>(nullable: true),
+                    AddressLine1 = table.Column<string>(nullable: true),
+                    AddressLine2 = table.Column<string>(nullable: true),
+                    AddressLine3 = table.Column<string>(nullable: true),
+                    SuburbId = table.Column<int>(nullable: false),
+                    CityId = table.Column<int>(nullable: false),
+                    ProvinceId = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Properties", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Properties_Cities_CityId",
+                        column: x => x.CityId,
+                        principalTable: "Cities",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Properties_PropertyTypes_PropertyTypeId",
+                        column: x => x.PropertyTypeId,
+                        principalTable: "PropertyTypes",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Properties_Provinces_ProvinceId",
+                        column: x => x.ProvinceId,
+                        principalTable: "Provinces",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Properties_Suburbs_SuburbId",
+                        column: x => x.SuburbId,
+                        principalTable: "Suburbs",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "PropertyImages",
+                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),
+                    PropertyId = table.Column<int>(nullable: false),
+                    Image = table.Column<string>(nullable: true),
+                    IsDefault = table.Column<bool>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PropertyImages", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_PropertyImages_Properties_PropertyId",
+                        column: x => x.PropertyId,
+                        principalTable: "Properties",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "PropertyUserFields",
+                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),
+                    PropertyId = table.Column<int>(nullable: false),
+                    UserDefinedFieldId = table.Column<int>(nullable: false),
+                    Value = table.Column<string>(nullable: true),
+                    Description = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PropertyUserFields", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_PropertyUserFields_Properties_PropertyId",
+                        column: x => x.PropertyId,
+                        principalTable: "Properties",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_PropertyUserFields_UserDefinedFields_UserDefinedFieldId",
+                        column: x => x.UserDefinedFieldId,
+                        principalTable: "UserDefinedFields",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Accounts_SMTPHostId",
+                table: "Accounts",
+                column: "SMTPHostId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Agents_AgencyId",
+                table: "Agents",
+                column: "AgencyId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Agents_UserId",
+                table: "Agents",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Cities_ProvinceId",
+                table: "Cities",
+                column: "ProvinceId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Emails_SenderId",
+                table: "Emails",
+                column: "SenderId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Individuals_UserId",
+                table: "Individuals",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Properties_CityId",
+                table: "Properties",
+                column: "CityId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Properties_PropertyTypeId",
+                table: "Properties",
+                column: "PropertyTypeId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Properties_ProvinceId",
+                table: "Properties",
+                column: "ProvinceId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Properties_SuburbId",
+                table: "Properties",
+                column: "SuburbId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PropertyImages_PropertyId",
+                table: "PropertyImages",
+                column: "PropertyId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PropertyUserFields_PropertyId",
+                table: "PropertyUserFields",
+                column: "PropertyId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PropertyUserFields_UserDefinedFieldId",
+                table: "PropertyUserFields",
+                column: "UserDefinedFieldId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Suburbs_CityId",
+                table: "Suburbs",
+                column: "CityId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UnitConfigurations_Code",
+                table: "UnitConfigurations",
+                column: "Code",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UnitConfigurationTypes_UnitConfigurationId",
+                table: "UnitConfigurationTypes",
+                column: "UnitConfigurationId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserDefinedFields_GroupId",
+                table: "UserDefinedFields",
+                column: "GroupId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Weeks_AgencyId",
+                table: "Weeks",
+                column: "AgencyId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Weeks_AgentId",
+                table: "Weeks",
+                column: "AgentId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Weeks_RegionId",
+                table: "Weeks",
+                column: "RegionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Weeks_StatusId",
+                table: "Weeks",
+                column: "StatusId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Weeks_UnitConfigurationId",
+                table: "Weeks",
+                column: "UnitConfigurationId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Emails");
+
+            migrationBuilder.DropTable(
+                name: "Individuals");
+
+            migrationBuilder.DropTable(
+                name: "PropertyImages");
+
+            migrationBuilder.DropTable(
+                name: "PropertyUserFields");
+
+            migrationBuilder.DropTable(
+                name: "Seasons");
+
+            migrationBuilder.DropTable(
+                name: "UnitConfigurationTypes");
+
+            migrationBuilder.DropTable(
+                name: "Weeks");
+
+            migrationBuilder.DropTable(
+                name: "Accounts");
+
+            migrationBuilder.DropTable(
+                name: "Properties");
+
+            migrationBuilder.DropTable(
+                name: "UserDefinedFields");
+
+            migrationBuilder.DropTable(
+                name: "Agents");
+
+            migrationBuilder.DropTable(
+                name: "Status");
+
+            migrationBuilder.DropTable(
+                name: "UnitConfigurations");
+
+            migrationBuilder.DropTable(
+                name: "Hosts");
+
+            migrationBuilder.DropTable(
+                name: "PropertyTypes");
+
+            migrationBuilder.DropTable(
+                name: "Suburbs");
+
+            migrationBuilder.DropTable(
+                name: "UserDefinedGroups");
+
+            migrationBuilder.DropTable(
+                name: "Agencies");
+
+            migrationBuilder.DropTable(
+                name: "Users");
+
+            migrationBuilder.DropTable(
+                name: "Cities");
+
+            migrationBuilder.DropTable(
+                name: "Provinces");
+        }
+    }
+}

UnivateProperties_API/Migrations/DataContextModelSnapshot.cs

@@ -0,0 +1,765 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using UnivateProperties_API.Context;
+
+namespace UnivateProperties_API.Migrations
+{
+    [DbContext(typeof(DataContext))]
+    partial class DataContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn)
+                .HasAnnotation("ProductVersion", "2.2.4-servicing-10062")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.Email", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("BCC");
+
+                    b.Property<string>("Body");
+
+                    b.Property<string>("CC");
+
+                    b.Property<string>("Comment");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsBodyHtml");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("SenderId");
+
+                    b.Property<string>("Subject");
+
+                    b.Property<string>("To");
+
+                    b.Property<string>("ToDisplay");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SenderId");
+
+                    b.ToTable("Emails");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.SMTPAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Address");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("DisplayName");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("SMTPHostId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SMTPHostId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.SMTPHost", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Host");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<bool>("NeedsAuthorize");
+
+                    b.Property<string>("Password");
+
+                    b.Property<bool>("UseSSL");
+
+                    b.Property<string>("User");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Hosts");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.Property", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AddressLine1");
+
+                    b.Property<string>("AddressLine2");
+
+                    b.Property<string>("AddressLine3");
+
+                    b.Property<int>("CityId");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsSale");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<decimal>("OperationalCosts");
+
+                    b.Property<decimal>("Price");
+
+                    b.Property<string>("PricePer");
+
+                    b.Property<string>("PropertyName");
+
+                    b.Property<int>("PropertyTypeId");
+
+                    b.Property<int>("ProvinceId");
+
+                    b.Property<string>("ShortDescription");
+
+                    b.Property<int>("SuburbId");
+
+                    b.Property<string>("Unit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CityId");
+
+                    b.HasIndex("PropertyTypeId");
+
+                    b.HasIndex("ProvinceId");
+
+                    b.HasIndex("SuburbId");
+
+                    b.ToTable("Properties");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyImage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Image");
+
+                    b.Property<bool>("IsDefault");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("PropertyId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PropertyId");
+
+                    b.ToTable("PropertyImages");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("UsageType");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyTypes");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyUserField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("PropertyId");
+
+                    b.Property<int>("UserDefinedFieldId");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PropertyId");
+
+                    b.HasIndex("UserDefinedFieldId");
+
+                    b.ToTable("PropertyUserFields");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.UserDefinedField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("FieldName");
+
+                    b.Property<string>("FieldType");
+
+                    b.Property<int>("GroupId");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("Rank");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("UserDefinedFields");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.UserDefinedGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("Rank");
+
+                    b.Property<int>("UsageType");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("UserDefinedGroups");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.City", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Code");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("ProvinceId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProvinceId");
+
+                    b.ToTable("Cities");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.Province", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Code");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Provinces");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.Suburb", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("CityId");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("PostalCode");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CityId");
+
+                    b.ToTable("Suburbs");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.Season", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Seasons");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.Status", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Code");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Status");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.TimeshareWeek", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AgencyId");
+
+                    b.Property<int>("AgentId");
+
+                    b.Property<DateTime>("ArrivalDate");
+
+                    b.Property<string>("BankedWith");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("CurrentYearBanked");
+
+                    b.Property<DateTime>("DepartureDate");
+
+                    b.Property<bool>("LeviesPaidInFull");
+
+                    b.Property<double>("LevyAmount");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Module");
+
+                    b.Property<DateTime>("OriginalPurchaseDate");
+
+                    b.Property<double>("OriginalPurchasePrice");
+
+                    b.Property<bool>("OtherResort");
+
+                    b.Property<bool>("ReferedByAgent");
+
+                    b.Property<int>("RegionId");
+
+                    b.Property<string>("ResortCode");
+
+                    b.Property<string>("ResortName");
+
+                    b.Property<string>("Season");
+
+                    b.Property<int>("StatusId");
+
+                    b.Property<int>("UnitConfigurationId");
+
+                    b.Property<string>("WeekNumber");
+
+                    b.Property<bool>("WeekPlacedForRental");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AgencyId");
+
+                    b.HasIndex("AgentId");
+
+                    b.HasIndex("RegionId");
+
+                    b.HasIndex("StatusId");
+
+                    b.HasIndex("UnitConfigurationId");
+
+                    b.ToTable("Weeks");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.UnitConfiguration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Adults");
+
+                    b.Property<int>("Bedrooms");
+
+                    b.Property<int>("Children");
+
+                    b.Property<string>("Code");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("UnitConfigurations");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.UnitConfigurationType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("UnitConfigurationId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UnitConfigurationId");
+
+                    b.ToTable("UnitConfigurationTypes");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Agency", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AgencyName");
+
+                    b.Property<string>("CompanyRegNumber");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("EAABEFFCNumber");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Agencies");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Agent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("AgencyId");
+
+                    b.Property<string>("CellNumber");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Email");
+
+                    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("AgencyId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Agents");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Individual", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("CellNumber");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Email");
+
+                    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("Individuals");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.Property<byte[]>("PasswordHash");
+
+                    b.Property<byte[]>("PasswordSalt");
+
+                    b.Property<string>("Role");
+
+                    b.Property<string>("Surname");
+
+                    b.Property<string>("Token");
+
+                    b.Property<string>("Username");
+
+                    b.Property<bool>("Verified");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.Email", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Communication.SMTPAccount", "Sender")
+                        .WithMany("Emails")
+                        .HasForeignKey("SenderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Communication.SMTPAccount", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Communication.SMTPHost", "SMTPHost")
+                        .WithMany("SMTPAccounts")
+                        .HasForeignKey("SMTPHostId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.Property", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Region.City", "City")
+                        .WithMany()
+                        .HasForeignKey("CityId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Property.PropertyType", "PropertyType")
+                        .WithMany()
+                        .HasForeignKey("PropertyTypeId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Region.Province", "Province")
+                        .WithMany()
+                        .HasForeignKey("ProvinceId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Region.Suburb", "Suburb")
+                        .WithMany()
+                        .HasForeignKey("SuburbId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyImage", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Property.Property", "Property")
+                        .WithMany("PropertyImages")
+                        .HasForeignKey("PropertyId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.PropertyUserField", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Property.Property", "Property")
+                        .WithMany("PropertyUserFields")
+                        .HasForeignKey("PropertyId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Property.UserDefinedField", "UserDefinedField")
+                        .WithMany()
+                        .HasForeignKey("UserDefinedFieldId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Property.UserDefinedField", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Property.UserDefinedGroup", "Group")
+                        .WithMany("Fields")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.City", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Region.Province", "Province")
+                        .WithMany()
+                        .HasForeignKey("ProvinceId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Region.Suburb", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Region.City", "City")
+                        .WithMany()
+                        .HasForeignKey("CityId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.TimeshareWeek", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Users.Agency", "Agency")
+                        .WithMany()
+                        .HasForeignKey("AgencyId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Users.Agent", "Agent")
+                        .WithMany()
+                        .HasForeignKey("AgentId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Region.Province", "Region")
+                        .WithMany()
+                        .HasForeignKey("RegionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Timeshare.Status", "Status")
+                        .WithMany()
+                        .HasForeignKey("StatusId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Timeshare.UnitConfiguration", "UnitConfiguration")
+                        .WithMany()
+                        .HasForeignKey("UnitConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Timeshare.UnitConfigurationType", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Timeshare.UnitConfiguration", "UnitConfiguration")
+                        .WithMany("Types")
+                        .HasForeignKey("UnitConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Agent", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Users.Agency", "Agency")
+                        .WithMany("Agents")
+                        .HasForeignKey("AgencyId");
+
+                    b.HasOne("UnivateProperties_API.Model.Users.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.Individual", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Users.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

UnivateProperties_API/Model/BaseEntity.cs

@@ -0,0 +1,43 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using UnivateProperties_API.Containers;
+
+namespace UnivateProperties_API.Model
+{
+    public class BaseEntity
+    {
+        #region Properties
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        [Key]
+        public int Id { get; set; }
+        public DateTime Created { get; set; } = DateTime.Now;
+        public DateTime Modified { get; set; } = DateTime.Now;
+        public string ModifiedBy { get; set; }
+        [NotMapped]
+        public ValidateEntity Valid { get; set; }
+        #endregion
+
+        #region Methods
+        public virtual void UpdateModified(string modifiedBy)
+        {
+            Modified = DateTime.Now;
+            if (string.IsNullOrEmpty(modifiedBy))
+            {
+                ModifiedBy = modifiedBy;
+            }
+        }
+
+        public void Validate()
+        {
+            Valid = ValidateObject();
+        }
+
+        public virtual ValidateEntity ValidateObject()
+        {
+            ValidateEntity v = new ValidateEntity();
+            return v;
+        }
+        #endregion Methods
+    }
+}

UnivateProperties_API/Model/Communication/Email.cs

@@ -0,0 +1,142 @@
+using UnivateProperties_API.Helpers;
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Net.Mail;
+using System.Text;
+
+namespace UnivateProperties_API.Model.Communication
+{
+    public class Email : BaseEntity
+    {
+        #region Constructor
+        public Email()
+        {
+            
+        }
+
+        public Email(int senderId)
+        {
+            SenderId = senderId;
+        }
+
+        public Email(int senderId, string toAddress, string toDisplay, string cc, string bcc, string subject, string body, bool isHtml = true)
+        {
+            SenderId = senderId;
+            To = toAddress;
+            ToDisplay = toDisplay;
+            BCC = bcc;
+            CC = cc;
+            IsBodyHtml = isHtml;
+            Body = body;
+            Subject = subject;
+        }
+        #endregion Constructor
+
+        #region Properties
+        [ForeignKey("Sender")]
+        public int SenderId { get; set; }
+        public string Comment { get; set; }
+        public string Subject { get; set; }
+        public bool IsBodyHtml { get; set; }
+        public string CC { get; set; }
+        public string BCC { get; set; }
+        public string Body { get; set; }
+        public string To { get; set; }
+        public string ToDisplay { get; set; }
+
+        public virtual SMTPAccount Sender { get; set; }
+        #endregion
+
+        #region Methods
+        public virtual void GetSMTPAccount()
+        {
+            if (SenderId > 0)
+            {
+
+            }
+        }
+
+        public virtual bool SendMail()
+        {
+            try
+            {
+                if (MyCommon.IsValidEmail(To))
+                {
+                    if (Sender != null && Sender.SMTPHost != null)
+                    {
+                        using (SmtpClient smtp = new SmtpClient(Sender.SMTPHost.Host))
+                        {
+                            MailMessage mail = GetMailMessage();
+                            smtp.UseDefaultCredentials = Sender.SMTPHost.NeedsAuthorize;
+                            smtp.Credentials = Sender.SMTPHost.GetNetworkCredential();
+                            smtp.EnableSsl = Sender.SMTPHost.UseSSL;
+                            smtp.Send(mail);
+                            Comment = "Send";
+                            return true;
+                        };
+                    }
+                    else Comment = "NoSender";
+                }
+            }
+            catch (SmtpFailedRecipientException ex)
+            {
+                SmtpStatusCode statusCode = ex.StatusCode;
+
+                if (statusCode == SmtpStatusCode.MailboxBusy ||
+                    statusCode == SmtpStatusCode.MailboxUnavailable ||
+                    statusCode == SmtpStatusCode.TransactionFailed)
+                {
+                    Comment = $"SmtpFailedRecipientException - Msg - {ex.Message} Stack - {ex.StackTrace}";
+                    //TODO: Return correct error message
+                    return false;
+                }
+                else
+                {
+                    Comment = $"SmtpFailedRecipientException - Msg - {ex.Message} Stack - {ex.StackTrace}";
+                    //TODO: Return correct error message
+                    return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                Comment = $"Exception - Msg - {ex.Message} Stack - {ex.StackTrace}";
+                //TODO: Return correct error message
+                return false;
+            }
+            return true;
+        }
+
+        private MailMessage GetMailMessage()
+        {
+            MailMessage mail = new MailMessage();
+            mail.To.Add(new MailAddress(To, ToDisplay));
+            if (!string.IsNullOrEmpty(CC))
+            {
+                foreach (var item in CC.Split(';'))
+                {
+                    mail.CC.Add(item);
+                }
+            }
+            if (!string.IsNullOrEmpty(BCC))
+            {
+                foreach (var item in BCC.Split(';'))
+                {
+                    mail.Bcc.Add(item);
+                }
+            }
+            mail.Subject = Subject;
+            mail.Body = Body;
+            mail.IsBodyHtml = IsBodyHtml;
+            if (IsBodyHtml)
+            {
+                mail.BodyEncoding = Encoding.ASCII;
+            }
+            else mail.BodyEncoding = Encoding.UTF8;
+            mail.DeliveryNotificationOptions = DeliveryNotificationOptions.OnFailure;
+            mail.Sender = new MailAddress(Sender.Address, Sender.DisplayName);
+            mail.From = mail.Sender;
+            return mail;
+        }
+        #endregion Methods
+    }
+}

UnivateProperties_API/Model/Communication/SMTPAccount.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Communication
+{
+    public class SMTPAccount : BaseEntity
+    {
+        #region Constructors
+        public SMTPAccount()
+        {
+
+        }
+
+        public SMTPAccount(string address)
+        {
+            Address = address;
+        }
+
+        public SMTPAccount(string address, string displayName)
+        {
+            Address = address;
+            DisplayName = displayName;
+        }
+
+        public SMTPAccount(string address, string displayName, int smtpHostId)
+        {
+            Address = address;
+            DisplayName = displayName;
+            SMTPHostId = smtpHostId;
+        }
+        #endregion Constructors
+
+        #region Properties
+        public string Address { get; set; }
+        public string DisplayName { get; set; }
+        [ForeignKey("SMTPHost")]
+        public int SMTPHostId { get; set; }
+
+        public virtual SMTPHost SMTPHost { get; set; }
+        public virtual ICollection<Email> Emails { get; set; }
+        #endregion Properties
+    }
+}

UnivateProperties_API/Model/Communication/SMTPHost.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Net;
+
+namespace UnivateProperties_API.Model.Communication
+{
+    public class SMTPHost : BaseEntity
+    {
+        #region Constructor
+        public SMTPHost()
+        {
+
+        }
+
+        public SMTPHost(string host, bool needsAutorize, string user, string password)
+        {
+            Host = host;
+            User = user;
+            NeedsAuthorize = needsAutorize;
+            Password = password;
+        }
+        #endregion
+
+        #region Properties
+        public string Host { get; set; }
+        public bool NeedsAuthorize { get; set; } = false;
+        public string User { get; set; }
+        public string Password { get; set; }
+        public bool UseSSL { get; set; } = false;
+
+        public virtual ICollection<SMTPAccount> SMTPAccounts { get; set; }
+        #endregion Properties
+
+        #region Methods
+        public NetworkCredential GetNetworkCredential()
+        {
+            if (NeedsAuthorize)
+            {
+                return new NetworkCredential(User, Password);
+            }
+            return null;
+        }
+        #endregion
+    }
+}

UnivateProperties_API/Model/Property/Property.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using UnivateProperties_API.Containers.Property;
+using UnivateProperties_API.Model.Region;
+
+namespace UnivateProperties_API.Model.Property
+{
+    public class Property : BaseEntity
+    {
+        #region Properties
+        [ForeignKey("PropertyType")]
+        public int PropertyTypeId { get; set; }
+        public string PropertyName { get; set; }
+        public string Unit { get; set; }
+        public decimal OperationalCosts { get; set; }           
+        public decimal Price { get; set; }
+        public string PricePer { get; set; }
+        public bool IsSale { get; set; }
+        public string Description { get; set; }
+        public string ShortDescription { get; set; }
+        public string AddressLine1 { get; set; }
+        public string AddressLine2 { get; set; }
+        public string AddressLine3 { get; set; }
+        public int SuburbId { get; set; }
+        public int CityId { get; set; }
+        public int ProvinceId { get; set; }
+
+        public virtual PropertyType PropertyType { get; set; }
+        public virtual Province Province { get; set; }
+        public virtual City City { get; set; }
+        public virtual Suburb Suburb { get; set; }
+
+        public ICollection<PropertyUserField> PropertyUserFields { get; set; }
+        public ICollection<PropertyImage> PropertyImages { get; set; }
+
+        [NotMapped]
+        public List<PropertyDetailGroup> DisplayData { get; set; }
+        #endregion
+    }
+}

UnivateProperties_API/Model/Property/PropertyImage.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Property
+{
+    public class PropertyImage : BaseEntity
+    {
+        #region Properties 
+        [ForeignKey("Property")]
+        public int PropertyId { get; set; }
+        public string Image { get; set; }
+        public bool IsDefault { get; set; }
+        public virtual Property Property { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Model/Property/PropertyType.cs

@@ -0,0 +1,10 @@
+namespace UnivateProperties_API.Model.Property
+{
+    public class PropertyType : BaseEntity
+    {
+        #region Properties 
+        public string Description { get; set; }
+        public PropertyUsageType UsageType { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Model/Property/PropertyUserField.cs

@@ -0,0 +1,19 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Property
+{
+    public class PropertyUserField : BaseEntity
+    {
+        #region Properties 
+        [ForeignKey("Property")]
+        public int PropertyId { get; set; }
+        [ForeignKey("UserDefinedField")]
+        public int UserDefinedFieldId { get; set; }
+        public string Value { get; set; }
+        public string Description { get; set; }
+
+        public virtual Property Property { get; set; }
+        public virtual UserDefinedField UserDefinedField { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Model/Property/UserDefinedField.cs

@@ -0,0 +1,17 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Property
+{
+    public class UserDefinedField : BaseEntity
+    {
+        #region Properties 
+        [ForeignKey("Group")]
+        public int GroupId { get; set; }
+        public string FieldName { get; set; }
+        public string FieldType { get; set; }        
+        public int Rank { get; set; }
+
+        public virtual UserDefinedGroup Group { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Model/Property/UserDefinedGroup.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+
+namespace UnivateProperties_API.Model.Property
+{
+    public class UserDefinedGroup : BaseEntity
+    {
+        #region Properties
+        public string Description { get; set; }
+        public PropertyUsageType UsageType { get; set; }
+        public int Rank { get; set; }
+
+        public ICollection<UserDefinedField> Fields { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Model/Region/City.cs

@@ -0,0 +1,16 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Region
+{
+    public class City :BaseEntity
+    {
+        #region Properties 
+        [ForeignKey("Province")]
+        public int ProvinceId { get; set; }
+        public string Description { get; set; }
+        public string Code { get; set; }
+
+        public virtual Province Province { get; set; }
+        #endregion
+    }
+}

UnivateProperties_API/Model/Region/Province.cs

@@ -0,0 +1,10 @@
+namespace UnivateProperties_API.Model.Region
+{
+    public class Province : BaseEntity
+    {
+        #region Properties
+        public string Description { get; set; }
+        public string Code { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Model/Region/Suburb.cs

@@ -0,0 +1,16 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Region
+{
+    public class Suburb : BaseEntity
+    {
+        #region Properties
+        [ForeignKey("City")]
+        public int CityId { get; set; }
+        public string Description { get; set; }
+        public string PostalCode { get; set; }
+
+        public virtual City City { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Model/Timeshare/Season.cs

@@ -0,0 +1,7 @@
+namespace UnivateProperties_API.Model.Timeshare
+{
+    public class Season : BaseEntity
+    {
+        public string Name { get; set; }
+    }
+}

UnivateProperties_API/Model/Timeshare/Status.cs

@@ -0,0 +1,8 @@
+namespace UnivateProperties_API.Model.Timeshare
+{
+    public class Status : BaseEntity
+    {
+        public string Code { get; set; }
+        public string Description { get; set; }
+    }
+}

UnivateProperties_API/Model/Timeshare/TimeshareWeek.cs

@@ -0,0 +1,51 @@
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+using UnivateProperties_API.Model.Region;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Model.Timeshare
+{
+    public class TimeshareWeek : BaseEntity
+    {
+        #region Properties
+        public bool ReferedByAgent { get; set; }
+        [ForeignKey("Agent")]
+        public int AgentId { get; set; }
+        [ForeignKey("Agency")]
+        public int AgencyId { get; set; }
+        [ForeignKey("UnitConfiguration")]
+        public int UnitConfigurationId { get; set; }
+
+        public bool OtherResort { get; set; }
+        public string ResortCode { get; set; }
+        public string ResortName { get; set; }
+        [ForeignKey("Region")]
+        public int RegionId { get; set; }
+        public string Season { get; set; }
+        public string Module { get; set; }
+        public string WeekNumber { get; set; }
+        public double LevyAmount { get; set; }
+
+        public bool CurrentYearBanked { get; set; }
+        public string BankedWith { get; set; }
+
+        public bool LeviesPaidInFull { get; set; }
+        public bool WeekPlacedForRental { get; set; }
+        public double OriginalPurchasePrice { get; set; }
+        public DateTime OriginalPurchaseDate { get; set; }
+        public DateTime ArrivalDate { get; set; }
+        public DateTime DepartureDate { get; set; }
+
+        [ForeignKey("Status")]
+        public int StatusId { get; set; }
+        #endregion
+
+        #region Navigation
+        public virtual Status Status { get; set; }
+        public virtual Province Region { get; set; }
+        public virtual Agent Agent { get; set; }
+        public virtual Agency Agency { get; set; }
+        public virtual UnitConfiguration UnitConfiguration { get; set; }
+        #endregion Navigation
+    }
+}

UnivateProperties_API/Model/Timeshare/UnitConfiguration.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace UnivateProperties_API.Model.Timeshare
+{
+    public class UnitConfiguration : BaseEntity
+    {
+        #region Properties
+        public string Code { get; set; }
+        public int Bedrooms { get; set; }
+        public int Adults { get; set; }
+        public int Children { get; set; }
+        #endregion Properties
+        #region Navigation
+        public virtual ICollection<UnitConfigurationType> Types { get; set; }
+        #endregion Navigation
+    }
+}

UnivateProperties_API/Model/Timeshare/UnitConfigurationType.cs

@@ -0,0 +1,28 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using UnivateProperties_API.Containers;
+
+namespace UnivateProperties_API.Model.Timeshare
+{
+    public class UnitConfigurationType : BaseEntity
+    {
+        #region Properties
+        public string Description { get; set; }
+        [ForeignKey("UnitConfiguration")]
+        public int UnitConfigurationId { get; set; }
+        #endregion Properties
+        #region Navigation
+        public virtual UnitConfiguration UnitConfiguration { get; set; }
+        #endregion Navigation
+        #region Methods
+        public override ValidateEntity ValidateObject()
+        {
+            ValidateEntity v = new ValidateEntity();
+            if (string.IsNullOrEmpty(Description))
+            {
+                v.Errors.Add("Description cant be blank");
+            }
+            return v;
+        }
+        #endregion
+    }
+}

UnivateProperties_API/Model/Users/Agency.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace UnivateProperties_API.Model.Users
+{
+    public class Agency : BaseEntity
+    {
+        #region Constructor
+        public Agency()
+        {
+
+        }
+        #endregion Constructor
+
+        #region Properties
+        public string AgencyName { get; set; }
+        public string EAABEFFCNumber { get; set; }
+        public string CompanyRegNumber { get; set; }
+
+        public virtual ICollection<Agent> Agents { get; set; }
+        #endregion Properties
+    }
+}

UnivateProperties_API/Model/Users/Agent.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Users
+{
+    public class Agent : Person
+    {
+        #region Constructor
+        public Agent()
+        {
+
+        }
+        #endregion Constructor
+
+        #region Properties
+        [ForeignKey("Agency")]
+        public int? AgencyId { get; set; }
+        public virtual Agency Agency { get; set; }
+        #endregion Properties
+    }
+}

UnivateProperties_API/Model/Users/AppSettings.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace UnivateProperties_API.Model.Users
+{
+    public class AppSettings
+    {
+        public string Secret { get; set; }
+    }
+}

UnivateProperties_API/Model/Users/Individual.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Users
+{
+    public class Individual : Person
+    {
+        #region Constructor
+        public Individual()
+        {
+
+        }
+        #endregion Constructor
+
+        #region Properties
+        
+        #endregion Properties
+    }
+}

UnivateProperties_API/Model/Users/Person.cs

@@ -0,0 +1,28 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Users
+{
+    public class Person : BaseEntity
+    {
+        #region Constructor
+        public Person()
+        {
+
+        }
+        #endregion Constructor
+
+        #region Properties
+        [ForeignKey("User")]
+        public int UserId { get; set; }
+        public string Name { get; set; }
+        public string Surname { get; set; }
+        public string Email { get; set; }
+        [Phone]
+        public string Telephone { get; set; }
+        [Phone]
+        public string CellNumber { get; set; }
+        public virtual User User { get; set; }
+        #endregion Properties
+    }
+}

UnivateProperties_API/Model/Users/User.cs

@@ -0,0 +1,23 @@
+namespace UnivateProperties_API.Model.Users
+{
+    public class User : BaseEntity
+    {
+        #region Constructor
+        public User()
+        {
+
+        }
+        #endregion Constructor
+
+        #region Properties
+        public string Name { get; set; }
+        public string Surname { get; set; }
+        public string Username { get; set; }
+        public string Role { get; set; }
+        public byte[] PasswordHash { get; set; }
+        public byte[] PasswordSalt { get; set; }
+        public bool Verified { get; set; }
+        public string Token { get; set; }
+        #endregion Properties
+    }
+}

UnivateProperties_API/Program.cs

@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+
+namespace UnivateProperties_API
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateWebHostBuilder(args).Build().Run();
+            BuildWebHost(args).Run();
+        }
+
+        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseStartup<Startup>();
+
+        public static IWebHost BuildWebHost(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseStartup<Startup>()
+                .UseUrls("http://192.168.6.188/Univate-API")
+                .Build();
+    }
+}

UnivateProperties_API/Properties/launchSettings.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false, 
+    "anonymousAuthentication": true, 
+    "iisExpress": {
+      "applicationUrl": "http://localhost:57260",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "api/values",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "UnivateProperties_API": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "api/values",
+      "applicationUrl": "http://localhost:5000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

UnivateProperties_API/Repository/Communication/EmailRepository.cs

@@ -0,0 +1,108 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Communication;
+
+namespace UnivateProperties_API.Repository.Communication
+{
+    public class EmailRepository : IRepository<Email>
+    {
+        private readonly DataContext _dbContext;
+
+        public EmailRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<Email> Get(Func<Email, bool> where)
+        {
+            return _dbContext.Emails.Where(where).ToList();
+        }
+
+        public List<Email> GetAll()
+        {
+            return _dbContext.Emails.ToList();
+        }
+
+        public Email GetDetailed(Func<Email, bool> first)
+        {
+            var item = _dbContext.Emails.FirstOrDefault(first);
+            SMTPAccountRepository account = new SMTPAccountRepository(_dbContext);
+            item = GetDetailedObject(item, account);
+            return item;
+        }
+
+        private Email GetDetailedObject(Email item, SMTPAccountRepository repo)
+        {
+            item.Sender = repo.GetDetailed(x => x.Id == item.SenderId);
+            return item;
+        }
+
+        public List<Email> GetDetailedAll()
+        {
+            var list = GetAll();
+            SMTPAccountRepository account = new SMTPAccountRepository(_dbContext);
+            foreach (var item in list)
+            {
+                item.Sender = account.GetDetailed(x => x.Id == item.SenderId);
+            }
+            return list;
+        }
+
+        public void Insert(Email item)
+        {
+            SMTPAccountRepository account = new SMTPAccountRepository(_dbContext);
+            item = GetDetailedObject(item, account);
+            item.SendMail();
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Email> items)
+        {
+            foreach (var item in items)
+            {
+                item.SendMail();
+                _dbContext.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(Email item)
+        {
+            var i = _dbContext.Emails.Find(item);
+            _dbContext.Emails.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Email> items)
+        {
+            foreach (var item in items)
+            {
+                Email i = _dbContext.Emails.Find(item);
+                _dbContext.Emails.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Emails.Find(item);
+            _dbContext.Emails.Remove(i);
+            Save();
+        }
+
+        public void Update(Email item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+    }
+}

UnivateProperties_API/Repository/Communication/SMTPAccountRepository.cs

@@ -0,0 +1,98 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Communication;
+
+namespace UnivateProperties_API.Repository.Communication
+{
+    public class SMTPAccountRepository : IRepository<SMTPAccount>
+    {
+        private readonly DataContext _dbContext;
+
+        public SMTPAccountRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<SMTPAccount> Get(Func<SMTPAccount, bool> where)
+        {
+            return _dbContext.Accounts.Where(where).ToList();
+        }
+
+        public List<SMTPAccount> GetAll()
+        {
+            return _dbContext.Accounts.ToList();
+        }
+
+        public SMTPAccount GetDetailed(Func<SMTPAccount, bool> first)
+        {
+            var item = _dbContext.Accounts.FirstOrDefault(first);
+            SMTPHostRepository host = new SMTPHostRepository(_dbContext);
+            item.SMTPHost = host.GetDetailed(x => x.Id == item.SMTPHostId);
+            return item;
+        }
+
+        public List<SMTPAccount> GetDetailedAll()
+        {
+            var list = GetAll();
+            SMTPHostRepository host = new SMTPHostRepository(_dbContext);
+            foreach (var item in list)
+            {
+                item.SMTPHost = host.GetDetailed(x => x.Id == item.SMTPHostId);
+            }
+            return list;
+        }
+
+        public void Insert(SMTPAccount item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<SMTPAccount> items)
+        {
+            foreach (var item in items)
+            {
+                _dbContext.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(SMTPAccount item)
+        {
+            var i = _dbContext.Accounts.Find(item);
+            _dbContext.Accounts.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<SMTPAccount> items)
+        {
+            foreach (var item in items)
+            {
+                SMTPAccount i = _dbContext.Accounts.Find(item);
+                _dbContext.Accounts.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Accounts.Find(item);
+            _dbContext.Accounts.Remove(i);
+            Save();
+        }
+
+        public void Update(SMTPAccount item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+    }
+}

UnivateProperties_API/Repository/Communication/SMTPHostRepository.cs

@@ -0,0 +1,89 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Communication;
+
+namespace UnivateProperties_API.Repository.Communication
+{
+    public class SMTPHostRepository : IRepository<SMTPHost>
+    {
+        private readonly DataContext _dbContext;
+
+        public SMTPHostRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<SMTPHost> Get(Func<SMTPHost, bool> where)
+        {
+            return _dbContext.Hosts.Where(where).ToList();
+        }
+
+        public List<SMTPHost> GetAll()
+        {
+            return _dbContext.Hosts.ToList();
+        }
+
+        public SMTPHost GetDetailed(Func<SMTPHost, bool> first)
+        {
+            return _dbContext.Hosts.FirstOrDefault(first);
+        }
+
+        public List<SMTPHost> GetDetailedAll()
+        {
+            return GetAll();
+        }
+
+        public void Insert(SMTPHost item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<SMTPHost> items)
+        {
+            foreach (var item in items)
+            {
+                _dbContext.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(SMTPHost item)
+        {
+            var i = _dbContext.Hosts.Find(item);
+            _dbContext.Hosts.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<SMTPHost> items)
+        {
+            foreach (var item in items)
+            {
+                SMTPHost i = _dbContext.Hosts.Find(item);
+                _dbContext.Hosts.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Hosts.Find(item);
+            _dbContext.Hosts.Remove(i);
+            Save();
+        }
+
+        public void Update(SMTPHost item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+    }
+}

UnivateProperties_API/Repository/IRepository.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Repository
+{
+    public interface IRepository<TEntity> where TEntity : class
+    {
+        List<TEntity> GetAll();
+        List<TEntity> Get(Func<TEntity, bool> where);
+        TEntity GetDetailed(Func<TEntity, bool> first);
+        List<TEntity> GetDetailedAll();
+        void Insert(TEntity item);
+        void Insert(IEnumerable<TEntity> items);
+        void Remove(TEntity item);
+        void Remove(IEnumerable<TEntity> items);
+        void RemoveAtId(int item);
+        void Update(TEntity item);
+        void Save();
+    }
+}

UnivateProperties_API/Repository/Properties/IPropertyImageRepository.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public interface IPropertyImageRepository : IRepository<PropertyImage>
+    {
+        List<string> GetImages(int PropertyId);
+    }
+}

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using UnivateProperties_API.Containers.Property;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public interface IPropertyRepository : IRepository<Property>
+    {
+        List<PropertyDisplay> GetDisplay();
+        List<PropertyDisplay> GetDisplay(Func<Property, bool> where);
+        List<PropertyDisplay> GetDisplay(string Keyword);
+        List<PropertyDisplay> GetDisplay(string type, string propertyType, string province, string city, string suburb, string propType);
+    }
+}

UnivateProperties_API/Repository/Properties/IUserDefinedGroupRepository.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using UnivateProperties_API.Containers.Property;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public interface IUserDefinedGroupRepository : IRepository<UserDefinedGroup>
+    {
+        List<Group> GetFieldList(string name);
+
+        List<Group> GetFieldListByPropType(string propertyType);
+    }
+}

UnivateProperties_API/Repository/Properties/PropertyImageRepository.cs

@@ -0,0 +1,98 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public class PropertyImageRepository : IPropertyImageRepository
+    {
+        private readonly DataContext dBContext;
+
+        public PropertyImageRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+        public List<PropertyImage> Get(Func<PropertyImage, bool> where)
+        {
+            return dBContext.PropertyImages.Where(where).ToList();
+        }
+
+        public List<PropertyImage> GetAll()
+        {
+            return dBContext.PropertyImages.ToList();
+        }
+
+        public PropertyImage GetDetailed(Func<PropertyImage, bool> first)
+        {
+            return dBContext.PropertyImages.FirstOrDefault(first);
+        }
+
+        public List<PropertyImage> GetDetailedAll()
+        {
+            throw new NotImplementedException();
+        }
+
+        public List<string> GetImages(int PropertyId)
+        {
+            var images = (from p in dBContext.PropertyImages
+                          where p.PropertyId == PropertyId
+                          select p.Image).ToList();
+
+            return images;
+        }
+
+        public void Insert(PropertyImage item)
+        {
+            dBContext.PropertyImages.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<PropertyImage> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.PropertyImages.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(PropertyImage item)
+        {
+            dBContext.PropertyImages.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<PropertyImage> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.PropertyImages.Remove(item);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var image = Get(x => x.Id == item).FirstOrDefault();
+            if (image != null)
+            {
+                dBContext.PropertyImages.Remove(image);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(PropertyImage item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

@@ -0,0 +1,340 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Containers.Property;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public class PropertyRepository : IPropertyRepository
+    {
+        private readonly DataContext dBContext;
+
+        public PropertyRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+
+        public List<Property> Get(Func<Property, bool> where)
+        {
+            return dBContext.Properties.Where(where).ToList();
+        }
+
+        public List<Property> GetAll()
+        {
+            var properties = dBContext.Properties.ToList();
+            return properties;
+        }
+
+        public Property GetDetailed(Func<Property, bool> first)
+        {
+            var property = dBContext.Properties.FirstOrDefault(first);
+            if (property != null)
+            {
+                GetDetail(ref property);
+            }
+            return property;
+        }
+
+        public List<Property> GetDetailedAll()
+        {
+            var properties = dBContext.Properties.ToList();
+            return properties;
+        }
+
+        private void GetDetail(ref Property property)
+        {
+            int propID = property.Id;
+            var propertyType = dBContext.PropertyTypes.Find(property.PropertyTypeId);
+            property.Province = dBContext.Provinces.Find(property.ProvinceId);
+            property.City = dBContext.Cities.Find(property.CityId);
+            property.Suburb = dBContext.Suburbs.Find(property.SuburbId);
+            property.DisplayData = new List<PropertyDetailGroup>();
+
+            var groups = (from g in dBContext.UserDefinedGroups
+                          where g.UsageType == propertyType.UsageType
+                          || g.UsageType == PropertyUsageType.Both
+                          orderby g.Rank
+                          select g).ToList();
+
+            foreach (UserDefinedGroup uGroup in groups)
+            {
+                var groupFields = (from f in dBContext.PropertyUserFields
+                                   join uf in dBContext.UserDefinedFields on f.UserDefinedFieldId equals uf.Id
+                                   join g in dBContext.UserDefinedGroups on uf.GroupId equals g.Id
+                                   where f.PropertyId == propID
+                                   && g.Id == uGroup.Id
+                                   orderby g.Rank, uf.Rank
+                                   select new { uf.FieldName, f.Value, f.Description }).ToList();
+
+                if (groupFields.Count > 0)
+                {
+                    PropertyDetailGroup detailGroup = new PropertyDetailGroup()
+                    {
+                        GroupName = uGroup.Description,
+                        Values = new List<PropertyDetail>()
+                    };
+
+                    if (uGroup.Description == "Property Overview")
+                    {
+                        detailGroup.Values.Add(new PropertyDetail()
+                        {
+                            Name = "Property Type",
+                            Value = property.PropertyType.Description
+                        });
+                    }
+
+                    foreach (var val in groupFields)
+                    {
+                        var irem = new PropertyDetail()
+                        {
+                            Name = val.FieldName,
+                            Description = val.Description
+                        };
+
+                        detailGroup.Values.Add(irem);
+
+                        if ((val.FieldName == "Erf Size" || val.FieldName == "Floor Size") && val.Value.EndsWith("2"))
+                        {
+                            irem.Value = val.Value.Substring(0, val.Value.Length - 1) + "<sup>" + val.Value.Last() + "</sup>";
+                        }
+                        else
+                            irem.Value = val.Value;
+                    }
+
+                    property.DisplayData.Add(detailGroup);
+                }
+            }
+        }
+
+        public void Insert(Property item)
+        {
+            PropertyType pt = dBContext.PropertyTypes.Find(item.PropertyTypeId);
+            if (pt != null)
+            {
+                if (pt.UsageType == PropertyUsageType.Residential)
+                {
+                    if (item.PropertyUserFields.Count > 0)
+                    {
+                        string shortDesc = "{0} {1} {2}";
+                        string type = dBContext.PropertyTypes.Find(item.PropertyTypeId).Description;
+                        UserDefinedField bedrooms = dBContext.UserDefinedFields.Where(u => u.FieldName == "Bedrooms").FirstOrDefault();
+                        var udValue = item.PropertyUserFields.Where(u => u.UserDefinedFieldId == bedrooms.Id).FirstOrDefault();
+                        if (udValue != null)
+                            item.ShortDescription = string.Format(shortDesc, udValue.Value, "Bedroom", pt.Description).Trim();
+                        else
+                            item.ShortDescription = string.Format(shortDesc, "", "", pt.Description).Trim();
+                    }
+                }
+                else
+                {
+                    item.ShortDescription = pt.Description;
+                }
+            }
+
+            dBContext.Properties.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Property> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.Properties.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(Property item)
+        {
+            dBContext.Properties.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Property> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.Properties.Remove(item);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var property = Get(x => x.Id == item).FirstOrDefault();
+            if (property != null)
+            {
+                dBContext.Properties.Remove(property);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(Property item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+
+        public List<PropertyDisplay> GetDisplay()
+        {
+            List<Property> props = GetAll();
+            return GetDisplayDetails(props);
+        }
+
+        public List<PropertyDisplay> GetDisplay(Func<Property, bool> where)
+        {
+            List<Property> props;
+            if (where != null)
+                props = Get(where);
+            else
+                props = GetAll();
+
+            return GetDisplayDetails(props);
+        }
+
+        public List<PropertyDisplay> GetDisplay(string Keyword)
+        {
+            Keyword = Keyword.ToLower();
+
+            List<Property> props = (from p in dBContext.Properties
+                                    join pr in dBContext.Provinces on p.ProvinceId equals pr.Id
+                                    join c in dBContext.Cities on p.CityId equals c.Id
+                                    join s in dBContext.Suburbs on p.SuburbId equals s.Id
+                                    join pt in dBContext.PropertyTypes on p.PropertyTypeId equals pt.Id
+                                    where EF.Functions.Like(p.PropertyName.ToLower(), $"%{Keyword}%")
+                                    || EF.Functions.Like(pr.Description.ToLower(), $"%{Keyword}%")
+                                    || EF.Functions.Like(c.Description.ToLower(), $"%{Keyword}%")
+                                    || EF.Functions.Like(s.Description.ToLower(), $"%{Keyword}%")
+                                    || EF.Functions.Like(pt.Description.ToLower(), $"%{Keyword}%")
+                                    select p).ToList();
+
+            return GetDisplayDetails(props);
+        }
+
+        public List<PropertyDisplay> GetDisplay(string type, string propertyType, string province, string city, string suburb, string propType)
+        {
+            List<Property> props;
+            PropertyUsageType uType = PropertyUsageType.Both;
+
+            if (propertyType != "" && propertyType != "undefined")
+            {
+                if (propertyType.ToUpper() == "COMMERCIAL")
+                    uType = PropertyUsageType.Commercial;
+                else
+                    uType = PropertyUsageType.Residential;
+            }
+            props = (from p in dBContext.Properties
+                     join pt in dBContext.PropertyTypes on p.PropertyTypeId equals pt.Id
+                     where pt.UsageType == uType
+                     select p).ToList();
+
+            if (type != "" && type != "undefined")
+            {
+                if (type.ToUpper() == "SALE")
+                    props = props.Where(p => p.IsSale).ToList();
+                else
+                    props = props.Where(p => !p.IsSale).ToList();
+            }
+
+            if (province != "" && province != "undefined" && province.ToUpper() != "ALL")
+            {
+                props = (from p in props
+                         join pp in dBContext.Provinces on p.ProvinceId equals pp.Id
+                         where pp.Description.ToUpper() == province.ToUpper()
+                         select p).ToList();
+            }
+
+            if (city != "" && city != "undefined" && city.ToUpper() != "ALL")
+            {
+                props = (from p in props
+                         join c in dBContext.Cities on p.CityId equals c.Id
+                         where c.Description.ToUpper() == city.ToUpper()
+                         select p).ToList();
+            }
+
+            if (suburb != "" && suburb != "undefined" && suburb.ToUpper() != "ALL")
+            {
+                props = (from p in props
+                         join s in dBContext.Suburbs on p.SuburbId equals s.Id
+                         where s.Description.ToUpper() == suburb.ToUpper()
+                         select p).ToList();
+            }
+            if (propType != "" && propType != "Undefined" && propType.ToUpper() != "ALL")
+            {
+                var pType = dBContext.PropertyTypes.Where(t => t.Description == propType).FirstOrDefault();
+                if (pType != null)
+                {
+                    props = props.Where(p => p.PropertyTypeId == pType.Id).ToList();
+                }
+            }
+
+            return GetDisplayDetails(props);
+        }
+
+        private List<PropertyDisplay> GetDisplayDetails(List<Property> props)
+        {
+            var properties = new List<PropertyDisplay>();
+            foreach (var item in props)
+            {
+                PropertyDisplay display = new PropertyDisplay
+                {
+                    Id = item.Id,
+                    ShortDescription = item.ShortDescription,
+                    IsSale = item.IsSale,
+                    DisplayPrice = string.Format("R {0}", item.Price.ToString("N0")),
+                    DisplayImage = (from i in dBContext.PropertyImages
+                                    where i.PropertyId == item.Id
+                                    && i.IsDefault
+                                    select i.Image).FirstOrDefault(),
+                    Area = (from u in dBContext.PropertyUserFields
+                            join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
+                            where u.PropertyId == item.Id
+                            && f.FieldName == "Floor Size"
+                            select u.Value).FirstOrDefault(),
+                    Beds = (from u in dBContext.PropertyUserFields
+                            join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
+                            where u.PropertyId == item.Id
+                            && f.FieldName == "Bedrooms"
+                            select u.Value).FirstOrDefault(),
+                    Baths = (from u in dBContext.PropertyUserFields
+                             join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
+                             where u.PropertyId == item.Id
+                             && f.FieldName == "Bathrooms"
+                             select u.Value).FirstOrDefault(),
+                    Garages = (from u in dBContext.PropertyUserFields
+                               join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
+                               where u.PropertyId == item.Id
+                               && f.FieldName == "Garages"
+                               select u.Value).FirstOrDefault(),
+                    Province = (from p in dBContext.Provinces
+                                where p.Id == item.ProvinceId
+                                select p.Description).FirstOrDefault(),
+                    City = (from c in dBContext.Cities
+                            where c.Id == item.CityId
+                            select c.Description).FirstOrDefault(),
+                    Suburb = (from s in dBContext.Suburbs
+                              where s.Id == item.SuburbId
+                              select s.Description).FirstOrDefault()
+
+                };
+
+                if (!string.IsNullOrEmpty(display.Area) && display.Area.EndsWith("2"))
+                {
+                    display.Area = display.Area.Substring(0, display.Area.Length - 1) + "<sup>" + display.Area.Last() + "</sup>";
+                }
+
+                properties.Add(display);
+            }
+
+            return properties;
+        }
+    }
+}

UnivateProperties_API/Repository/Properties/PropertyTypeRepository.cs

@@ -0,0 +1,90 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public class PropertyTypeRepository : IRepository<PropertyType>
+    {
+        private readonly DataContext dBContext;
+
+        public PropertyTypeRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+
+        public List<PropertyType> Get(Func<PropertyType, bool> where)
+        {
+            return dBContext.PropertyTypes.Where(where).ToList();
+        }
+
+        public List<PropertyType> GetAll()
+        {
+            return dBContext.PropertyTypes.ToList();
+        }
+
+        public PropertyType GetDetailed(Func<PropertyType, bool> first)
+        {
+            return dBContext.PropertyTypes.FirstOrDefault(first);
+        }
+
+        public List<PropertyType> GetDetailedAll()
+        {
+            return dBContext.PropertyTypes.ToList();
+        }
+
+        public void Insert(PropertyType item)
+        {
+            dBContext.PropertyTypes.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<PropertyType> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.PropertyTypes.Add(item);
+                Save();
+            }
+        }
+
+        public void Remove(PropertyType item)
+        {
+            dBContext.PropertyTypes.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<PropertyType> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.PropertyTypes.Remove(item);
+                Save();
+            }
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var propertyType = Get(x => x.Id == item).FirstOrDefault();
+            if (propertyType != null)
+            {
+                dBContext.PropertyTypes.Remove(propertyType);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(PropertyType item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Properties/PropertyUserFieldRepository.cs

@@ -0,0 +1,90 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public class PropertyUserFieldRepository : IRepository<PropertyUserField>
+    {
+        private readonly DataContext dBContext;
+
+        public PropertyUserFieldRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+
+        public List<PropertyUserField> Get(Func<PropertyUserField, bool> where)
+        {
+            return dBContext.PropertyUserFields.Where(where).ToList();
+        }
+
+        public List<PropertyUserField> GetAll()
+        {
+            return dBContext.PropertyUserFields.ToList();
+        }
+
+        public PropertyUserField GetDetailed(Func<PropertyUserField, bool> first)
+        {
+            return dBContext.PropertyUserFields.FirstOrDefault(first);
+        }
+
+        public List<PropertyUserField> GetDetailedAll()
+        {
+            return dBContext.PropertyUserFields.ToList();
+        }
+
+        public void Insert(PropertyUserField item)
+        {
+            dBContext.PropertyUserFields.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<PropertyUserField> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.PropertyUserFields.Add(item);
+                Save();
+            }
+        }
+
+        public void Remove(PropertyUserField item)
+        {
+            dBContext.PropertyUserFields.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<PropertyUserField> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.PropertyUserFields.Remove(item);
+                Save();
+            }
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var propertyUserField = Get(x => x.Id == item).FirstOrDefault();
+            if (propertyUserField != null)
+            {
+                dBContext.PropertyUserFields.Remove(propertyUserField);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(PropertyUserField item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Properties/UserDefinedFieldRepository.cs

@@ -0,0 +1,90 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public class UserDefinedFieldRepository : IRepository<UserDefinedField>
+    {
+        private readonly DataContext dBContext;
+
+        public UserDefinedFieldRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+
+        public List<UserDefinedField> Get(Func<UserDefinedField, bool> where)
+        {
+            return dBContext.UserDefinedFields.Where(where).ToList();
+        }
+
+        public List<UserDefinedField> GetAll()
+        {
+            return dBContext.UserDefinedFields.ToList();
+        }
+
+        public UserDefinedField GetDetailed(Func<UserDefinedField, bool> first)
+        {
+            return dBContext.UserDefinedFields.FirstOrDefault(first);
+        }
+
+        public List<UserDefinedField> GetDetailedAll()
+        {
+            return dBContext.UserDefinedFields.ToList();
+        }
+
+        public void Insert(UserDefinedField item)
+        {
+            dBContext.UserDefinedFields.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<UserDefinedField> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.UserDefinedFields.Add(item);
+                Save();
+            }
+        }
+
+        public void Remove(UserDefinedField item)
+        {
+            dBContext.UserDefinedFields.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<UserDefinedField> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.UserDefinedFields.Add(item);
+                Save();
+            }
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var userDefinedField = Get(x => x.Id == item).FirstOrDefault();
+            if (userDefinedField != null)
+            {
+                dBContext.UserDefinedFields.Remove(userDefinedField);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(UserDefinedField item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Properties/UserDefinedGroupRepository.cs

@@ -0,0 +1,174 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Containers.Property;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Property;
+
+namespace UnivateProperties_API.Repository.Properties
+{
+    public class UserDefinedGroupRepository : IUserDefinedGroupRepository
+    {
+        private readonly DataContext dBContext;
+
+        public UserDefinedGroupRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+
+        public List<UserDefinedGroup> Get(Func<UserDefinedGroup, bool> where)
+        {
+            return dBContext.UserDefinedGroups.Where(where).ToList();
+        }
+
+        public List<UserDefinedGroup> GetAll()
+        {
+            return dBContext.UserDefinedGroups.ToList();
+        }
+
+        public UserDefinedGroup GetDetailed(Func<UserDefinedGroup, bool> first)
+        {
+            return dBContext.UserDefinedGroups.FirstOrDefault(first);
+        }
+
+        public List<UserDefinedGroup> GetDetailedAll()
+        {
+            return dBContext.UserDefinedGroups.ToList();
+        }
+
+        public List<Group> GetFieldList(string name)
+        {
+            List<Group> FieldGroups = new List<Group>();
+            List<UserDefinedGroup> Groups;
+            if (name == "Property Overview")
+                Groups = dBContext.UserDefinedGroups.Where(x => x.Description == "Property Overview").OrderBy(x => x.Rank).ToList();
+            else
+                Groups = dBContext.UserDefinedGroups.Where(x => x.Description != "Property Overview").OrderBy(x => x.Rank).ToList();
+
+
+            foreach (var group in Groups)
+            {
+                var fields = dBContext.UserDefinedFields.Where(x => x.GroupId == group.Id).ToList();
+                if (fields.Count > 0)
+                {
+                    var item = new Group()
+                    {
+                        Name = group.Description,
+                        Fields = new List<GroupFields>()
+                    };
+
+                    FieldGroups.Add(item);
+
+                    foreach (var field in fields)
+                    {
+                        item.Fields.Add(new GroupFields()
+                        {
+                            ID = field.Id,
+                            Name = field.FieldName,
+                            Type = field.FieldType
+                        });
+                    }
+                }
+            }
+
+            return FieldGroups;
+        }
+
+        public List<Group> GetFieldListByPropType(string propertyType)
+        {
+            List<Group> FieldGroups = new List<Group>();
+            List<UserDefinedGroup> Groups;
+            PropertyUsageType usageType = PropertyUsageType.Both;
+            switch (propertyType.ToUpper())
+            {
+                case "RESIDENTIAL":
+                    usageType = PropertyUsageType.Residential;
+                    break;
+                case "COMMERCIAL":
+                    usageType = PropertyUsageType.Commercial;
+                    break;
+            }
+
+            Groups = dBContext.UserDefinedGroups.Where(x => (x.UsageType == usageType || x.UsageType == PropertyUsageType.Both) && x.Description != "Property Overview").OrderBy(x => x.Rank).ToList();
+
+            foreach (var group in Groups)
+            {
+                var fields = dBContext.UserDefinedFields.Where(x => x.GroupId == group.Id).ToList();
+                if (fields.Count > 0)
+                {
+                    var item = new Group()
+                    {
+                        Name = group.Description,
+                        Fields = new List<GroupFields>()
+                    };
+
+                    FieldGroups.Add(item);
+
+                    foreach (var field in fields)
+                    {
+                        item.Fields.Add(new GroupFields()
+                        {
+                            ID = field.Id,
+                            Name = field.FieldName,
+                            Type = field.FieldType
+                        });
+                    }
+                }
+            }
+
+            return FieldGroups;
+        }
+
+        public void Insert(UserDefinedGroup item)
+        {
+            dBContext.UserDefinedGroups.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<UserDefinedGroup> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.UserDefinedGroups.Add(item);
+                Save();
+            }
+        }
+
+        public void Remove(UserDefinedGroup item)
+        {
+            dBContext.UserDefinedGroups.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<UserDefinedGroup> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.UserDefinedGroups.Remove(item);
+                Save();
+            }
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var userDefinedGroups = Get(x => x.Id == item).FirstOrDefault();
+            if (userDefinedGroups != null)
+            {
+                dBContext.UserDefinedGroups.Remove(userDefinedGroups);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(UserDefinedGroup item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Region/CityRepository.cs

@@ -0,0 +1,99 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Region;
+
+namespace UnivateProperties_API.Repository.Region
+{
+    public class CityRepository : ICityRepository
+    {
+        private readonly DataContext dBContext;
+
+        public CityRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+
+        public List<City> Get(Func<City, bool> where)
+        {
+            return dBContext.Cities.Where(where).ToList();
+        }        
+
+        public List<City> GetAll()
+        {
+            return dBContext.Cities.ToList();
+        }
+
+        public List<City> GetBy(string province)
+        {
+            var provObj = dBContext.Provinces.Where(p => p.Description == province).First();
+            if (provObj != null)
+                return dBContext.Cities.Where(c => c.ProvinceId == provObj.Id).OrderBy(c => c.Description).ToList();
+            else
+                return null;
+        }
+
+        public City GetDetailed(Func<City, bool> first)
+        {
+            throw new NotImplementedException();
+        }
+
+        public List<City> GetDetailedAll()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Insert(City item)
+        {
+            dBContext.Cities.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<City> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.Cities.Add(item);
+                Save();
+            }
+        }
+
+        public void Remove(City item)
+        {
+            dBContext.Cities.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<City> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.Cities.Remove(item);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var city = Get(x => x.Id == item).FirstOrDefault();
+            if (city != null)
+            {
+                dBContext.Cities.Remove(city);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(City item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Region/ICityRepository.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using UnivateProperties_API.Model.Region;
+
+namespace UnivateProperties_API.Repository.Region
+{
+    public interface ICityRepository : IRepository<City>
+    {
+        List<City> GetBy(string province);
+    }
+}

UnivateProperties_API/Repository/Region/ISuburbRepository.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using UnivateProperties_API.Model.Region;
+
+namespace UnivateProperties_API.Repository.Region
+{
+    public interface ISuburbRepository : IRepository<Suburb>
+    {
+        List<Suburb> GetBy(string province, string city);
+    }
+}

UnivateProperties_API/Repository/Region/ProvinceRepository.cs

@@ -0,0 +1,90 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Region;
+
+namespace UnivateProperties_API.Repository.Region
+{
+    public class ProvinceRepository : IRepository<Province>
+    {
+        private readonly DataContext dBContext;
+
+        public ProvinceRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+
+        public List<Province> Get(Func<Province, bool> where)
+        {
+            return dBContext.Provinces.Where(where).ToList();
+        }
+
+        public List<Province> GetAll()
+        {
+            return dBContext.Provinces.OrderBy(p => p.Description).ToList();
+        }
+
+        public Province GetDetailed(Func<Province, bool> first)
+        {
+            throw new NotImplementedException();
+        }
+
+        public List<Province> GetDetailedAll()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Insert(Province item)
+        {
+            dBContext.Provinces.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Province> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.Provinces.Add(item);
+                Save();
+            }
+        }
+
+        public void Remove(Province item)
+        {
+            dBContext.Provinces.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Province> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.Provinces.Remove(item);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var province = Get(x => x.Id == item).FirstOrDefault();
+            if (province != null)
+            {
+                dBContext.Provinces.Remove(province);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(Province item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Region/SuburbRepository.cs

@@ -0,0 +1,100 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Region;
+
+namespace UnivateProperties_API.Repository.Region
+{
+    public class SuburbRepository : ISuburbRepository
+    {
+        private readonly DataContext dBContext;
+
+        public SuburbRepository(DataContext _dBContext)
+        {
+            dBContext = _dBContext;
+        }
+
+        public List<Suburb> Get(Func<Suburb, bool> where)
+        {
+            return dBContext.Suburbs.Where(where).ToList();
+        }
+
+        public List<Suburb> GetAll()
+        {
+            return dBContext.Suburbs.ToList();
+        }
+
+        public List<Suburb> GetBy(string province, string city)
+        {
+            var provObj = dBContext.Provinces.Where(p => p.Description == province).FirstOrDefault();
+            var cityObj = dBContext.Cities.Where(c => c.ProvinceId == provObj.Id && c.Description == city).FirstOrDefault();
+            if (cityObj != null)
+                return dBContext.Suburbs.Where(s => s.CityId == cityObj.Id).OrderBy(s => s.Description).ToList();
+            else
+                return null;
+        }
+
+        public Suburb GetDetailed(Func<Suburb, bool> first)
+        {
+            throw new NotImplementedException();
+        }
+
+        public List<Suburb> GetDetailedAll()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Insert(Suburb item)
+        {
+            dBContext.Suburbs.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Suburb> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.Suburbs.Add(item);
+                Save();
+            }
+        }
+
+        public void Remove(Suburb item)
+        {
+            dBContext.Suburbs.Remove(item);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Suburb> items)
+        {
+            foreach (var item in items)
+            {
+                dBContext.Suburbs.Remove(item);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var suburb = Get(x => x.Id == item).FirstOrDefault();
+            if (suburb != null)
+            {
+                dBContext.Suburbs.Remove(suburb);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(Suburb item)
+        {
+            dBContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Timeshare/SeasonRepository.cs

@@ -0,0 +1,90 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Timeshare;
+
+namespace UnivateProperties_API.Repository.Timeshare
+{
+    public class SeasonRepository : IRepository<Season>
+    {
+        private readonly DataContext _dbContext;
+
+        public SeasonRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<Season> Get(Func<Season, bool> where)
+        {
+            return _dbContext.Seasons.Where(where).ToList();
+        }
+
+        public List<Season> GetAll()
+        {
+            return _dbContext.Seasons.ToList();
+        }
+
+        public Season GetDetailed(Func<Season, bool> first)
+        {
+            var item = _dbContext.Seasons.FirstOrDefault(first);
+            return item;
+        }
+
+        public List<Season> GetDetailedAll()
+        {
+            return GetAll();
+        }
+
+        public void Insert(Season item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Season> items)
+        {
+            foreach (var item in items)
+            {
+                _dbContext.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(Season item)
+        {
+            var i = _dbContext.Seasons.Find(item);
+            _dbContext.Seasons.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Season> items)
+        {
+            foreach (var item in items)
+            {
+                var i = _dbContext.Seasons.Find(item);
+                _dbContext.Seasons.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Seasons.Find(item);
+            _dbContext.Seasons.Remove(i);
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        public void Update(Season item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Timeshare/StatusRepository.cs

@@ -0,0 +1,90 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Timeshare;
+
+namespace UnivateProperties_API.Repository.Timeshare
+{
+    public class StatusRepository : IRepository<Status>
+    {
+        private readonly DataContext _dbContext;
+
+        public StatusRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<Status> Get(Func<Status, bool> where)
+        {
+            return _dbContext.Status.Where(where).ToList();
+        }
+
+        public List<Status> GetAll()
+        {
+            return _dbContext.Status.ToList();
+        }
+
+        public Status GetDetailed(Func<Status, bool> first)
+        {
+            var item = _dbContext.Status.FirstOrDefault(first);
+            return item;
+        }
+
+        public List<Status> GetDetailedAll()
+        {
+            return GetAll();
+        }
+
+        public void Insert(Status item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Status> items)
+        {
+            foreach (var item in items)
+            {
+                _dbContext.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(Status item)
+        {
+            var i = _dbContext.Status.Find(item);
+            _dbContext.Status.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Status> items)
+        {
+            foreach (var item in items)
+            {
+                var i = _dbContext.Status.Find(item);
+                _dbContext.Status.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Status.Find(item);
+            _dbContext.Status.Remove(i);
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        public void Update(Status item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Timeshare/UnitConfigurationRepository.cs

@@ -0,0 +1,141 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Containers.Timeshare;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Timeshare;
+
+namespace UnivateProperties_API.Repository.Timeshare
+{
+    public class UnitConfigurationRepository : IRepository<UnitConfiguration>
+    {
+        private readonly DataContext _dbContext;
+
+        public UnitConfigurationRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<UnitConfiguration> Get(Func<UnitConfiguration, bool> where)
+        {
+            return _dbContext.UnitConfigurations.Where(where).ToList();
+        }
+
+        public List<UnitConfigurationType> GetTypes(Func<UnitConfigurationType, bool> where)
+        {
+            return _dbContext.UnitConfigurationTypes.Where(where).ToList();
+        }
+
+        public List<UnitConfiguration> GetAll()
+        {
+            return _dbContext.UnitConfigurations.ToList();
+        }
+
+        public UnitConfiguration GetDetailed(Func<UnitConfiguration, bool> first)
+        {
+            var item = _dbContext.UnitConfigurations.FirstOrDefault(first);
+            item.Types = GetTypes(t => t.UnitConfigurationId == item.Id);
+            return item;
+        }
+
+        public List<UnitConfigurationDto> GetMyDetailed()
+        {
+            var list = new List<UnitConfigurationDto>();
+            UnitConfigurationDto dto = new UnitConfigurationDto();
+
+            foreach (var item in GetAll())
+            {
+                dto = new UnitConfigurationDto()
+                {
+                    Id = item.Id,
+                    Code = item.Code,
+                    Bedrooms = item.Bedrooms,
+                    Adults = item.Adults,
+                    Children = item.Children
+                };
+                dto.Types = new List<string>();
+                foreach (var subItem in GetTypes(t => t.UnitConfigurationId == item.Id))
+                {
+                    dto.Types.Add(subItem.Description);
+                }
+                list.Add(dto);
+            }
+            return list;
+        }
+
+        public List<UnitConfiguration> GetDetailedAll()
+        {
+            var list = new List<UnitConfiguration>();
+            foreach(var item in GetAll())
+            {
+                item.Types = GetTypes(t => t.UnitConfigurationId == item.Id);
+                list.Add(item);
+            }
+            return list;
+        }
+
+        public void Insert(UnitConfiguration item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void InsertType(UnitConfigurationType type)
+        {
+            _dbContext.Add(type);
+            Save();
+        }
+
+        public void Insert(IEnumerable<UnitConfiguration> items)
+        {
+            foreach (var item in items)
+            {
+                _dbContext.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(UnitConfiguration item)
+        {
+            var i = _dbContext.UnitConfigurations.Find(item);
+            _dbContext.UnitConfigurations.Remove(i);
+            Save();
+        }
+
+        public void RemoveType(UnitConfigurationType item)
+        {
+            var i = _dbContext.UnitConfigurationTypes.Find(item);
+            _dbContext.UnitConfigurationTypes.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<UnitConfiguration> items)
+        {
+            foreach (var item in items)
+            {
+                var i = _dbContext.UnitConfigurations.Find(item);
+                _dbContext.UnitConfigurations.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.UnitConfigurations.Find(item);
+            _dbContext.UnitConfigurations.Remove(i);
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        public void Update(UnitConfiguration item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Timeshare/WeekRepository.cs

@@ -0,0 +1,129 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Repository.Region;
+using UnivateProperties_API.Repository.Users;
+
+namespace UnivateProperties_API.Repository.Timeshare
+{
+    public class WeekRepository : IRepository<TimeshareWeek>
+    {
+        private readonly DataContext _dbContext;
+
+        public WeekRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<TimeshareWeek> Get(Func<TimeshareWeek, bool> where)
+        {
+            return _dbContext.Weeks.Where(where).ToList();
+        }
+
+        public List<TimeshareWeek> GetAll()
+        {
+            return _dbContext.Weeks.ToList();
+        }
+
+        private TimeshareWeek GetWeekDetailed(TimeshareWeek week)
+        {
+            // Get Agent
+            if(week.AgentId != 0 && week.Agent == null)
+            {
+                AgentRepository agentRepo = new AgentRepository(_dbContext);
+                week.Agent = agentRepo.GetDetailed(x => x.Id == week.AgentId);
+            }
+            // Get Agency
+            if(week.AgencyId != 0 && week.Agency == null)
+            {
+                AgencyRepository agencyRepo = new AgencyRepository(_dbContext);
+                week.Agency = agencyRepo.GetDetailed(x => x.Id == week.AgencyId);
+            }
+            // Get Region
+            if(week.RegionId != 0 && week.Region == null)
+            {
+                ProvinceRepository provinceRepo = new ProvinceRepository(_dbContext);
+                week.Region = provinceRepo.GetDetailed(x => x.Id == week.RegionId);
+            }
+            // Get Status
+            if(week.StatusId != 0 && week.Status == null)
+            {
+                StatusRepository statusRepo = new StatusRepository(_dbContext);
+                week.Status = statusRepo.GetDetailed(x => x.Id == week.StatusId);
+            }
+            return week;
+        }
+
+        public TimeshareWeek GetDetailed(Func<TimeshareWeek, bool> first)
+        {
+            var item = _dbContext.Weeks.FirstOrDefault(first);
+            item = GetWeekDetailed(item);
+            return item;
+        }
+
+        public List<TimeshareWeek> GetDetailedAll()
+        {
+            var list = GetAll();
+            List<TimeshareWeek> weeklist = new List<TimeshareWeek>();
+            foreach(var item in list)
+            {
+                weeklist.Add(GetWeekDetailed(item));
+            }
+            return weeklist;
+        }
+
+        public void Insert(TimeshareWeek item)
+        {
+            item = GetWeekDetailed(item);
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<TimeshareWeek> items)
+        {
+            foreach (var item in items)
+            {
+                _dbContext.Add(item);
+            }
+            Save();
+        }
+
+        public void Remove(TimeshareWeek item)
+        {
+            var i = _dbContext.Weeks.Find(item);
+            _dbContext.Weeks.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<TimeshareWeek> items)
+        {
+            foreach (var item in items)
+            {
+                var i = _dbContext.Weeks.Find(item);
+                _dbContext.Weeks.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Weeks.Find(item);
+            _dbContext.Weeks.Remove(i);
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();            
+        }
+
+        public void Update(TimeshareWeek item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Users/AgencyRepository.cs

@@ -0,0 +1,97 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Repository.Users
+{
+    public class AgencyRepository : IRepository<Agency>
+    {
+        private readonly DataContext _dbContext;
+
+        public AgencyRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<Agency> Get(Func<Agency, bool> where)
+        {
+            return _dbContext.Agencies.Where(where).ToList();
+        }
+
+        public List<Agency> GetAll()
+        {
+            return _dbContext.Agencies.ToList();
+        }
+
+        public Agency GetDetailed(Func<Agency, bool> first)
+        {
+            var item = _dbContext.Agencies.FirstOrDefault(first);
+            AgencyRepository account = new AgencyRepository(_dbContext);
+            item = GetDetailedObject(item, account);
+            return item;
+        }
+
+        private Agency GetDetailedObject(Agency item, AgencyRepository repo)
+        {
+            item = repo.GetDetailed(x => x.Id == item.Id);
+            return item;
+        }
+
+        public void Insert(Agency item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Agency> item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Remove(Agency item)
+        {
+            var i = _dbContext.Agencies.Find(item);
+            _dbContext.Agencies.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Agency> items)
+        {
+            foreach (var item in items)
+            {
+                Agency i = _dbContext.Agencies.Find(item);
+                _dbContext.Agencies.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Agencies.Find(item);
+            _dbContext.Agencies.Remove(i);
+            Save();
+        }
+
+        public void Update(Agency item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        public List<Agency> GetDetailedAll()
+        {
+            //TODO: GetDetailed Agency
+            throw new NotImplementedException();
+        }
+    }
+}

UnivateProperties_API/Repository/Users/AgentRepository.cs

@@ -0,0 +1,96 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Repository.Users
+{
+    public class AgentRepository : IRepository<Agent>
+    {
+        private readonly DataContext _dbContext;
+
+        public AgentRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<Agent> Get(Func<Agent, bool> where)
+        {
+            return _dbContext.Agents.Where(where).ToList();
+        }
+
+        public List<Agent> GetAll()
+        {
+            return _dbContext.Agents.ToList();
+        }
+
+        public Agent GetDetailed(Func<Agent, bool> first)
+        {
+            var item = _dbContext.Agents.FirstOrDefault(first);
+            AgentRepository account = new AgentRepository(_dbContext);
+            item = GetDetailedObject(item, account);
+            return item;
+        }
+
+        private Agent GetDetailedObject(Agent item, AgentRepository repo)
+        {
+            item = repo.GetDetailed(x => x.Id == item.Id);
+            return item;
+        }
+
+        public void Insert(Agent item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Agent> item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Remove(Agent item)
+        {
+            var i = _dbContext.Agents.Find(item);
+            _dbContext.Agents.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Agent> items)
+        {
+            foreach (var item in items)
+            {
+                Agent i = _dbContext.Agents.Find(item);
+                _dbContext.Agents.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Agents.Find(item);
+            _dbContext.Agents.Remove(i);
+            Save();
+        }
+
+        public void Update(Agent item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        public List<Agent> GetDetailedAll()
+        {
+            // TODO: GetDetailed
+            throw new NotImplementedException();
+        }
+    }
+}

UnivateProperties_API/Repository/Users/IRegisterRepository.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using UnivateProperties_API.Containers.Users;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Repository.Users
+{
+    public interface IRegisterRepository
+    {
+        User Authenticate(string username, string password);
+        IEnumerable<User> GetAllUsers();
+        IEnumerable<Agency> GetAllAgencies();
+        IEnumerable<Individual> GetAllIndividuals();
+        User GetById(int id);
+        Agency GetByAgencyId(int id);
+        Individual GetByIndividualId(int id);
+        User Create(User user, string password, bool save);
+        Agency CreateAgency(AgencyDto agency);
+        void CreatePerson(UserDto individual, PersonType personType, bool save, Agency agency);
+        void Update(User user, string password = null);
+        void UpdateAgency(Agency agency, string agencyname = null);
+        void UpdatePerson(Person person, PersonType personType);
+        void Delete(int id);
+        void DeleteAgency(int id);
+        void DeleteIndividual(int id);
+    }
+}

UnivateProperties_API/Repository/Users/IndividualRepository.cs

@@ -0,0 +1,96 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Repository.Users
+{
+    public class IndividualRepository : IRepository<Individual>
+    {
+        private readonly DataContext _dbContext;
+
+        public IndividualRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<Individual> Get(Func<Individual, bool> where)
+        {
+            return _dbContext.Individuals.Where(where).ToList();
+        }
+
+        public List<Individual> GetAll()
+        {
+            return _dbContext.Individuals.ToList();
+        }
+
+        public Individual GetDetailed(Func<Individual, bool> first)
+        {
+            var item = _dbContext.Individuals.FirstOrDefault(first);
+            IndividualRepository account = new IndividualRepository(_dbContext);
+            item = GetDetailedObject(item, account);
+            return item;
+        }
+
+        private Individual GetDetailedObject(Individual item, IndividualRepository repo)
+        {
+            item = repo.GetDetailed(x => x.Id == item.Id);
+            return item;
+        }
+
+        public void Insert(Individual item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Individual> item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Remove(Individual item)
+        {
+            var i = _dbContext.Individuals.Find(item);
+            _dbContext.Individuals.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Individual> items)
+        {
+            foreach (var item in items)
+            {
+                Individual i = _dbContext.Individuals.Find(item);
+                _dbContext.Individuals.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Individuals.Find(item);
+            _dbContext.Individuals.Remove(i);
+            Save();
+        }
+
+        public void Update(Individual item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        public List<Individual> GetDetailedAll()
+        {
+            // TODO: GetDetailed
+            throw new NotImplementedException();
+        }
+    }
+}

UnivateProperties_API/Repository/Users/RegisterRepository.cs

@@ -0,0 +1,325 @@
+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;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Repository.Users
+{
+    public class RegisterRepository : IRegisterRepository
+    {
+        private readonly DataContext _dbContext;
+
+        private readonly AppSettings _appSettings;
+
+        public RegisterRepository(DataContext dbContext, IOptions<AppSettings> appSettings)
+        {
+            _dbContext = dbContext;
+            _appSettings = appSettings.Value;
+        }
+
+        public User Authenticate(string username, string password)
+        {
+            if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
+                return null;
+
+            var user = _dbContext.Users.SingleOrDefault(x => x.Username == username);
+
+            // check if username exists
+            if (user == null)
+                return null;
+
+            // check if password is correct
+            if (!VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
+                return null;
+
+            // authentication successful
+            return user;
+        }
+
+        public User Create(User user, string password, bool save)
+        {
+            // validation
+            if (string.IsNullOrWhiteSpace(password))
+                throw new AppException("Password is required");
+
+            if (_dbContext.Users.Any(x => x.Username == user.Username))
+                throw new AppException("Username \"" + user.Username + "\" is already taken");
+
+            byte[] passwordHash, passwordSalt;
+            CreatePasswordHash(password, out passwordHash, out passwordSalt);
+
+            user.PasswordHash = passwordHash;
+            user.PasswordSalt = passwordSalt;
+
+            _dbContext.Users.Add(user);
+            if (save)
+            {
+                _dbContext.SaveChanges();
+            }
+
+            return user;
+        }
+
+        public Agency CreateAgency(AgencyDto agency)
+        {
+            // validation
+            if (string.IsNullOrWhiteSpace(agency.EaabeffcNumber))
+                throw new AppException("eaabeffcNumber is required");
+
+            if (_dbContext.Agencies.Any(x => x.EAABEFFCNumber == agency.EaabeffcNumber))
+                throw new AppException("eaabeffcNumber \"" + agency.EaabeffcNumber + "\" already exists");
+
+            Agency a = new Agency()
+            {
+                AgencyName = agency.Name,
+                EAABEFFCNumber = agency.EaabeffcNumber,
+                CompanyRegNumber = agency.RegNo
+            };
+
+            _dbContext.Agencies.Add(a);
+            CreatePerson(agency.User, PersonType.Agent, false, a);
+
+            _dbContext.SaveChanges();
+
+            return a;
+        }
+
+        public void CreatePerson(UserDto individual, PersonType personType, bool save, Agency agency)
+        {
+            // validation
+            if (string.IsNullOrWhiteSpace(individual.Password))
+                throw new AppException("Password is required");
+
+            if (_dbContext.Users.Any(x => x.Username == individual.Username))
+                throw new AppException("Individual \"" + individual.Username + "\" is already taken");
+            byte[] passwordHash, passwordSalt;
+
+            CreatePasswordHash(individual.Password, out passwordHash, out passwordSalt);
+
+            User createUser = new User()
+            {
+                Username = individual.Username,
+                PasswordHash = passwordHash,
+                PasswordSalt = passwordSalt
+            };
+            Create(createUser, individual.Password, save);
+            Person person = new Person()
+            {
+            };
+            if (personType == PersonType.Agent)
+            {
+                Agent agent = new Agent()
+                {
+                    Name = individual.Name,
+                    Surname = individual.Surname,
+                    User = createUser,
+                    Email = individual.Email,
+                    CellNumber = individual.CellNumber,
+                    Telephone = individual.Telephone,
+                    Agency = agency
+                };
+                _dbContext.Agents.Add(agent);
+            }
+            else if (personType == PersonType.Individual)
+            {
+                Individual i = new Individual()
+                {
+                    Name = individual.Name,
+                    Surname = individual.Surname,
+                    User = createUser,
+                    Email = individual.Email,
+                    CellNumber = individual.CellNumber,
+                    Telephone = individual.Telephone
+                };
+                _dbContext.Individuals.Add(i);
+            }
+            if (save)
+            {
+                Save();
+            }
+        }
+
+        public void UpdatePerson(Person person, PersonType personType)
+        {
+            if (personType == PersonType.Agent)
+            {
+                var item = (person as Agent);
+                _dbContext.Entry(item).State = EntityState.Modified;
+                Save();
+            }
+            else if (personType == PersonType.Individual)
+            {
+                var item = (person as Individual);
+                _dbContext.Entry(item).State = EntityState.Modified;
+                Save();
+            }
+        }
+
+        public void Update(User userParam, string password = null)
+        {
+            var user = _dbContext.Users.Find(userParam.Id);
+
+            if (user == null)
+                throw new AppException("User not found");
+
+            if (userParam.Username != user.Username)
+            {
+                // username has changed so check if the new username is already taken
+                if (_dbContext.Users.Any(x => x.Username == userParam.Username))
+                    throw new AppException("Username " + userParam.Username + " is already taken");
+            }
+
+            // update user properties
+            user.Name = userParam.Name;
+            user.Surname = userParam.Surname;
+            user.Username = userParam.Username;
+
+            // update password if it was entered
+            if (!string.IsNullOrWhiteSpace(password))
+            {
+                byte[] passwordHash, passwordSalt;
+                CreatePasswordHash(password, out passwordHash, out passwordSalt);
+
+                user.PasswordHash = passwordHash;
+                user.PasswordSalt = passwordSalt;
+            }
+
+            _dbContext.Users.Update(user);
+            _dbContext.SaveChanges();
+        }
+
+        public void UpdateAgency(Agency agencyParam, string agencyname = null)
+        {
+            var agency = _dbContext.Agencies.Find(agencyParam.Id);
+
+            if (agency == null)
+                throw new AppException("Agency not found");
+
+            if (agencyParam.AgencyName != agency.AgencyName)
+            {
+                // username has changed so check if the new username is already taken
+                if (_dbContext.Agencies.Any(x => x.AgencyName == agencyParam.AgencyName))
+                    throw new AppException("AgencyName " + agencyParam.AgencyName + " is already taken");
+            }
+
+            // update user properties
+            agency.AgencyName = agencyParam.AgencyName;
+            agency.EAABEFFCNumber = agencyParam.EAABEFFCNumber;
+            agency.CompanyRegNumber = agencyParam.CompanyRegNumber;
+
+            // update password if it was entered
+            _dbContext.Agencies.Update(agency);
+            _dbContext.SaveChanges();
+        }
+
+        [Authorize(Roles = Role.SuperAdmin)]
+        public IEnumerable<User> GetAllUsers()
+        {
+            return _dbContext.Users;
+        }
+
+        [Authorize(Roles = Role.SuperAdmin)]
+        public IEnumerable<Agency> GetAllAgencies()
+        {
+            return _dbContext.Agencies;
+        }
+
+        [Authorize(Roles = Role.SuperAdmin)]
+        public IEnumerable<Individual> GetAllIndividuals()
+        {
+            return _dbContext.Individuals;
+        }
+
+        public User GetById(int id)
+        {
+            return _dbContext.Users.Find(id);
+        }
+
+        public Agency GetByAgencyId(int id)
+        {
+            return _dbContext.Agencies.Find(id);
+        }
+
+        public Individual GetByIndividualId(int id)
+        {
+            return _dbContext.Individuals.Find(id);
+        }
+
+        public void Delete(int id)
+        {
+            var user = _dbContext.Users.Find(id);
+            if (user != null)
+            {
+                _dbContext.Users.Remove(user);
+                _dbContext.SaveChanges();
+            }
+        }
+
+        public void DeleteAgency(int id)
+        {
+            var agency = _dbContext.Agencies.Find(id);
+            if (agency != null)
+            {
+                _dbContext.Remove(agency);
+                _dbContext.SaveChanges();
+            }
+        }
+
+        public void DeleteIndividual(int id)
+        {
+            var individual = _dbContext.Individuals.Find(id);
+            if (individual != null)
+            {
+                _dbContext.Individuals.Remove(individual);
+                _dbContext.SaveChanges();
+            }
+        }
+
+        private void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        private static void CreatePasswordHash(string password, out byte[] passwordHash, out byte[] passwordSalt)
+        {
+            if (password == null) throw new ArgumentNullException("password");
+            if (string.IsNullOrWhiteSpace(password)) throw new ArgumentException("Value cannot be empty or whitespace only string.", "password");
+
+            using (var hmac = new System.Security.Cryptography.HMACSHA512())
+            {
+                passwordSalt = hmac.Key;
+                passwordHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password));
+            }
+        }
+
+        private static bool VerifyPasswordHash(string password, byte[] storedHash, byte[] storedSalt)
+        {
+            if (password == null) throw new ArgumentNullException("password");
+            if (string.IsNullOrWhiteSpace(password)) throw new ArgumentException("Value cannot be empty or whitespace only string.", "password");
+            if (storedHash.Length != 64) throw new ArgumentException("Invalid length of password hash (64 bytes expected).", "passwordHash");
+            if (storedSalt.Length != 128) throw new ArgumentException("Invalid length of password salt (128 bytes expected).", "passwordHash");
+
+            using (var hmac = new System.Security.Cryptography.HMACSHA512(storedSalt))
+            {
+                var computedHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password));
+                for (int i = 0; i < computedHash.Length; i++)
+                {
+                    if (computedHash[i] != storedHash[i]) return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}

UnivateProperties_API/Repository/Users/UserRepository.cs

@@ -0,0 +1,100 @@
+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.Context;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Repository.Users
+{
+    public class UserRepository : IRepository<User>
+    {
+        private readonly DataContext _dbContext;
+
+        public UserRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<User> Get(Func<User, bool> where)
+        {
+            return _dbContext.Users.Where(where).ToList();
+        }
+
+        public List<User> GetAll()
+        {
+            return _dbContext.Users.ToList();
+        }
+
+        public User GetDetailed(Func<User, bool> first)
+        {
+            var item = _dbContext.Users.FirstOrDefault(first);
+            UserRepository account = new UserRepository(_dbContext);
+            item = GetDetailedObject(item, account);
+            return item;
+        }
+
+        private User GetDetailedObject(User item, UserRepository repo)
+        {
+            item = repo.GetDetailed(x => x.Id == item.Id);
+            return item;
+        }
+
+        public void Insert(User item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<User> item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Remove(User item)
+        {
+            var i = _dbContext.Users.Find(item);
+            _dbContext.Users.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<User> items)
+        {
+            foreach (var item in items)
+            {
+                User i = _dbContext.Users.Find(item);
+                _dbContext.Users.Remove(i);
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Users.Find(item);
+            _dbContext.Users.Remove(i);
+            Save();
+        }
+
+        public void Update(User item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        public List<User> GetDetailedAll()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

UnivateProperties_API/Startup.cs

@@ -0,0 +1,147 @@
+using AutoMapper;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Cors.Internal;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.IdentityModel.Tokens;
+using System.Text;
+using System.Threading.Tasks;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Communication;
+using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Region;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Model.Users;
+using UnivateProperties_API.Repository;
+using UnivateProperties_API.Repository.Communication;
+using UnivateProperties_API.Repository.Properties;
+using UnivateProperties_API.Repository.Region;
+using UnivateProperties_API.Repository.Timeshare;
+using UnivateProperties_API.Repository.Users;
+
+namespace UnivateProperties_API
+{
+    public class Startup
+    {
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddAutoMapper();
+            services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
+            {
+                builder.AllowAnyOrigin()
+                       .AllowAnyMethod()
+                       .AllowAnyHeader();
+            }));
+            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
+            services.AddDbContext<DataContext>(o => o.UseNpgsql(Configuration.GetConnectionString("DefaultConnection")));
+
+            var appSettingsSection = Configuration.GetSection("AppSettings");
+            services.Configure<AppSettings>(appSettingsSection);
+
+            // configure jwt authentication
+            var appSettings = appSettingsSection.Get<AppSettings>();
+            var key = Encoding.ASCII.GetBytes(appSettings.Secret);
+            services.AddAuthentication(x =>
+            {
+                x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+                x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+            })
+            .AddJwtBearer(x =>
+            {
+                x.Events = new JwtBearerEvents
+                {
+                    OnTokenValidated = context =>
+                    {
+                        var registerRepository = context.HttpContext.RequestServices.GetRequiredService<IRegisterRepository>();
+                        var userId = int.Parse(context.Principal.Identity.Name);
+                        var user = registerRepository.GetById(userId);
+                        if (user == null)
+                        {
+                            // return unauthorized if user no longer exists
+                            context.Fail("Unauthorized");
+                        }
+                        return Task.CompletedTask;
+                    }
+                };
+                x.RequireHttpsMetadata = false;
+                x.SaveToken = true;
+                x.TokenValidationParameters = new TokenValidationParameters
+                {
+                    ValidateIssuerSigningKey = true,
+                    IssuerSigningKey = new SymmetricSecurityKey(key),
+                    ValidateIssuer = false,
+                    ValidateAudience = false
+                };
+            });
+
+            #region Property
+            services.AddTransient<IRepository<Agent>, AgentRepository>();
+            services.AddTransient<IRegisterRepository, RegisterRepository>();
+            services.AddTransient<IRepository<Agency>, AgencyRepository>();
+            services.AddTransient<IRepository<Email>, EmailRepository>();
+            services.AddTransient<IRepository<SMTPAccount>, SMTPAccountRepository>();
+            services.AddTransient<IRepository<SMTPHost>, SMTPHostRepository>();
+            services.AddTransient<IPropertyRepository, PropertyRepository>();
+            services.AddTransient<IPropertyImageRepository, PropertyImageRepository>();
+            services.AddTransient<IRepository<PropertyType>, PropertyTypeRepository>();
+            services.AddTransient<IRepository<PropertyUserField>, PropertyUserFieldRepository>();
+            services.AddTransient<IRepository<UserDefinedField>, UserDefinedFieldRepository>();
+            services.AddTransient<IUserDefinedGroupRepository, UserDefinedGroupRepository>();
+            #endregion Property
+            #region Region
+            services.AddTransient<IRepository<Province>, ProvinceRepository>();
+            services.AddTransient<ICityRepository, CityRepository>();
+            services.AddTransient<ISuburbRepository, SuburbRepository>();
+            #endregion Region
+            #region Timeshare
+            services.AddTransient<IRepository<Status>, StatusRepository>();
+            services.AddTransient<IRepository<Season>, SeasonRepository>();
+            services.AddTransient<IRepository<UnitConfiguration>, UnitConfigurationRepository>();
+            services.AddTransient<IRepository<TimeshareWeek>, WeekRepository>();
+            #endregion Timeshare
+            #region User
+            services.AddScoped<IRegisterRepository, RegisterRepository>();
+            services.AddTransient<IRepository<Agent>, AgentRepository>();
+            services.AddTransient<IRegisterRepository, RegisterRepository>();
+            services.AddTransient<IRepository<Agency>, AgencyRepository>();
+            services.AddTransient<IRepository<User>, UserRepository>();
+            services.AddTransient<IRepository<Individual>, IndividualRepository>();
+            #endregion User
+            #region Communication
+            services.AddTransient<IRepository<Email>, EmailRepository>();
+            services.AddTransient<IRepository<SMTPAccount>, SMTPAccountRepository>();
+            services.AddTransient<IRepository<SMTPHost>, SMTPHostRepository>();
+            #endregion Communication
+            services.Configure<MvcOptions>(options =>
+            {
+                options.Filters.Add(new CorsAuthorizationFilterFactory("MyPolicy"));
+            });
+        }
+
+        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+            app.UseCors(x => x
+                .AllowAnyOrigin()
+                .AllowAnyMethod()
+                .AllowAnyHeader());
+            app.UseAuthentication();
+            app.UseHttpsRedirection();
+            app.UseMvc();
+        }
+    }
+}

UnivateProperties_API/UnivateProperties_API.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
+    <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Migrations\20190826105340_InitialCreate.cs" />
+    <Compile Remove="Migrations\20190826105340_InitialCreate.Designer.cs" />
+    <Compile Remove="Model\Users\AgencyAgent.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Abp.AutoMapper" Version="4.8.1" />
+    <PackageReference Include="AutoMapper" Version="9.0.0" />
+    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.2.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.2.4" />
+    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.2.3" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.2.4" />
+  </ItemGroup>
+
+</Project>