Added fields and bank entity

UnivateProperties_API/Containers/Property/GroupFields.cs

         public int ID { get; set; }
         public string Name { get; set; }
         public string Type { get; set; }
+        public string Value { get; set; }
         #endregion
     }
 }

UnivateProperties_API/Containers/Property/PropertyDisplay.cs

-namespace UnivateProperties_API.Containers.Property
+using System;
+
+namespace UnivateProperties_API.Containers.Property
 {
     public class PropertyDisplay
     {
         public string City { get; set; }
         public string Suburb { get; set; }
         public string DisplayImage { get; set; }
+        public decimal Price { get; set; }
+        public DateTime DateCreated { get; set; }
         #endregion 
     }
 }

UnivateProperties_API/Containers/Property/PropertyList.cs

+namespace UnivateProperties_API.Containers.Property
+{
+    public class PropertyList
+    {
+        #region Properties
+        public string Name { get; set; }
+        public int Id { get; set; }
+        public string Size { get; set; }
+        public string Price { get; set; }
+        public string Type { get; set; }
+        public string Publish { get; set; }
+        public string Status { get; set; }
+        #endregion
+    }
+}

UnivateProperties_API/Containers/Users/AgentDto.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Containers.Users
+{
+    public class AgentDto
+    {
+        public Agent Agent { get; set; }
+        public string Password { get; set; }
+    }
+}

UnivateProperties_API/Context/DataContext.cs

 using Microsoft.EntityFrameworkCore;
 using UnivateProperties_API.Model.Communication;
 using UnivateProperties_API.Model.Users;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Model.Region;
 using UnivateProperties_API.Model.Timeshare;
 using System.Linq;
 using UnivateProperties_API.Model;
 using UnivateProperties_API.Model.Bank;
+using UnivateProperties_API.Model.Misc;
 
 namespace UnivateProperties_API.Context
 {
         public virtual DbSet<Agent> Agents { get; set; }
         public virtual DbSet<User> Users { get; set; }
         public virtual DbSet<Individual> Individuals { get; set; }
+        public virtual DbSet<Address> Addresses { get; set; }
         #endregion User
 
         #region Communication

UnivateProperties_API/Controllers/Properties/PropertyController.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Transactions;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Repository.Properties;
 
 namespace UnivateProperties_API.Controllers.Properties
 {
-    [Route("Property/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class PropertyController : ControllerBase
     {
             _Repo = repo;
         }
 
+        #region Get Methods
         [HttpGet]
         public IActionResult Get()
         {
 
                 if (string.IsNullOrEmpty(by) || by.ToUpper() == "ALL")
                 {
-                    return new OkObjectResult(_Repo.Get(x => proptypeIds.Contains(x.PropertyTypeId)));
+                    return new OkObjectResult(_Repo.GetPropertyList(x => proptypeIds.Contains(x.PropertyTypeId)));
                 }
                 else
                 {
-                    return new OkObjectResult(_Repo.Get(x => proptypeIds.Contains(x.PropertyTypeId) && x.CreatedBy == by));
+                    return new OkObjectResult(_Repo.GetPropertyList(x => proptypeIds.Contains(x.PropertyTypeId) && x.CreatedBy == by));
                 }
             }
             else
                 return new NoContentResult();
         }
 
+        [HttpGet("GetEditDisplay/{id}")]
+        public IActionResult GetEditDisplay(int id)
+        {
+            return new OkObjectResult(_Repo.GetPropertyList(x => x.Id == id));
+        }
+        #endregion
+
         [HttpPost]
         public IActionResult Post([FromBody] Property property)
         {

UnivateProperties_API/Controllers/Properties/PropertyFieldsController.cs

 
 namespace UnivateProperties_API.Controllers.Properties
 {
-    [Route("Property/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class PropertyFieldsController : ControllerBase
     {
         {
             return new OkObjectResult(_Repo.GetFieldListByPropType(type));
         }
+
+        [HttpGet("GetSavedValues/{propertyType}/{name}/{id}")]
+        public IActionResult GetSavedValues(string propertyType, string name, int id)
+        {
+            return new OkObjectResult(_Repo.GetFieldList(propertyType, name, id));
+        }
     }
 
 

UnivateProperties_API/Controllers/Properties/PropertyImageController.cs

 using System.Transactions;
 using Microsoft.AspNetCore.Mvc;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Repository.Properties;
 
 namespace UnivateProperties_API.Controllers.Properties
 {
-    [Route("Property/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class PropertyImageController : ControllerBase
     {

UnivateProperties_API/Controllers/Properties/PropertyTypeController.cs

 using System.Transactions;
 using Microsoft.AspNetCore.Mvc;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Repository;
 
 namespace UnivateProperties_API.Controllers.Properties
 {
-    [Route("Property/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class PropertyTypeController : ControllerBase
     {

UnivateProperties_API/Controllers/Properties/PropertyUserFieldController.cs

 using System.Transactions;
 using Microsoft.AspNetCore.Mvc;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Repository;
 
 namespace UnivateProperties_API.Controllers.Properties
 {
-    [Route("Property/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class PropertyUserFieldController : ControllerBase
     {
             return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
         }
 
+        [HttpGet("PropertyFields/{id}")]
+        public IActionResult GetPropertyFields(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.PropertyId == id));
+        }
+
         [HttpPost]
         public IActionResult Post([FromBody] PropertyUserField propertyUserField)
         {

UnivateProperties_API/Controllers/Properties/UserDefinedFieldController.cs

 using System.Transactions;
 using Microsoft.AspNetCore.Mvc;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Repository;
 
 namespace UnivateProperties_API.Controllers.Properties
 {
-    [Route("Property/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class UserDefinedFieldController : ControllerBase
     {

UnivateProperties_API/Controllers/Properties/UserDefinedGroupController.cs

 using System.Transactions;
 using Microsoft.AspNetCore.Mvc;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Repository.Properties;
 
 namespace UnivateProperties_API.Controllers.Properties
 {
-    [Route("Property/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class UserDefinedGroupController : ControllerBase
     {

UnivateProperties_API/Controllers/Region/CityController.cs

 
 namespace UnivateProperties_API.Controllers.Region
 {
-    [Route("Region/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class CityController : ControllerBase
     {

UnivateProperties_API/Controllers/Region/ProvinceController.cs

 
 namespace UnivateProperties_API.Controllers.Region
 {
-    [Route("Region/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class ProvinceController : ControllerBase
     {

UnivateProperties_API/Controllers/Region/SuburbController.cs

 
 namespace UnivateProperties_API.Controllers.Region
 {
-    [Route("Region/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class SuburbController : ControllerBase
     {

UnivateProperties_API/Controllers/Users/AgentController.cs

 using System.Transactions;
 using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Containers.Users;
+using UnivateProperties_API.Helpers;
 using UnivateProperties_API.Model.Users;
 using UnivateProperties_API.Repository;
-using UnivateProperties_API.Repository.Users;
 
 namespace User_API.Controllers
 {
         }
 
         [HttpPost()]
-        public IActionResult Post([FromBody] Agent agent)
+        public IActionResult Post([FromBody] AgentDto agentDto)
         {
             using (var scope = new TransactionScope())
             {
-                
+                Agent agent = agentDto.Agent;
+                byte[] passwordHash, passwordSalt;
+                MyCommon.CreatePasswordHash(agentDto.Password, out passwordHash, out passwordSalt);
+
+                agent.User.PasswordHash = passwordHash;
+                agent.User.PasswordSalt = passwordSalt;
                 _Repo.Insert(agent);
                 scope.Complete();
-                return CreatedAtAction(nameof(Get), new { id = agent.Id }, agent);
+                return CreatedAtAction(nameof(Get), new { id = agentDto.Agent.Id }, agentDto.Agent);
             }
         }
 

UnivateProperties_API/Controllers/Users/RegisterController.cs

 using UnivateProperties_API.Model.Users;
 using UnivateProperties_API.Repository;
 using UnivateProperties_API.Repository.Users;
+using System.Net.Http;
+using System.Net;
+using System.Web.Http;
 
 namespace UnivateProperties_API.Controllers.Users
 {
         {
             var user = _Repo.Authenticate(userDto.Username, userDto.Password);
 
+            //HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Unauthorized, "value");
+
             if (user == null)
                 return BadRequest(new { message = "Username or password is incorrect" });
 
                 SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
             };
             var token = tokenHandler.CreateToken(tokenDescriptor);
-            var tokenString = tokenHandler.WriteToken(token); 
-
+            var tokenString = tokenHandler.WriteToken(token);
             // return basic user info (without password) and token to store client side
             return Ok(new
             {

UnivateProperties_API/Helpers/MyCommon.cs

-using System.Text.RegularExpressions;
+using System;
+using System.Text.RegularExpressions;
 
 namespace UnivateProperties_API.Helpers
 {
             }
             else return false;
         }
+
+        public 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));
+            }
+        }
+
+        public 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/Model/Misc/Address.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace UnivateProperties_API.Model.Misc
+{
+    public class Address : BaseEntity
+    {
+        public string StreetNumber { get; set; }
+        public string Street { get; set; }
+        public string Suburb { get; set; }
+        public string City { get; set; }
+        public string PostalCode { get; set; }
+    }
+}

UnivateProperties_API/Model/ProcessFlow/ProcessFlow.cs

+using UnivateProperties_API.Model.Timeshare;
+
+namespace UnivateProperties_API.Model.ProcessFlow
+{
+    public class ProcessFlow : BaseEntity
+    {
+        public int? TimeshareID { get; set; }
+        public int? PropertyID { get; set; }
+        public int StatusID { get; set; }
+
+
+        public virtual TimeshareWeek Timeshare { get; set; }
+        public virtual Properties.Property Property { get; set; }
+        public virtual Status Status { get; set; }
+
+        public override string ToString()
+        {
+            return $"{(TimeshareID ?? PropertyID).Value} - {Status?.Code}";
+        }
+    }
+}

UnivateProperties_API/Model/Property/Property.cs → UnivateProperties_API/Model/Properties/Property.cs

 using System.ComponentModel.DataAnnotations.Schema;
 using UnivateProperties_API.Containers.Property;
 using UnivateProperties_API.Model.Region;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Model.Users;
 
-namespace UnivateProperties_API.Model.Property
+namespace UnivateProperties_API.Model.Properties
 {
     public class Property : BaseEntity
     {
         public int CityId { get; set; }
         public int ProvinceId { get; set; }
         public bool Published { get; set; }
+        public int? StatusId { get; set; }
+        public int? OwnerId { get; set; }
+        public int? AgentId { get; set; }
+        public int? AgencyId { 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 virtual Status Status { get; set; }
+        public virtual Individual Owner { get; set; }
+        public virtual Agent Agent { get; set; }
+        public virtual Agency Agency { get; set; }
 
         public ICollection<PropertyUserField> PropertyUserFields { get; set; }
         public ICollection<PropertyImage> PropertyImages { get; set; }

UnivateProperties_API/Model/Property/PropertyImage.cs → UnivateProperties_API/Model/Properties/PropertyImage.cs

 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace UnivateProperties_API.Model.Property
+namespace UnivateProperties_API.Model.Properties
 {
     public class PropertyImage : BaseEntity
     {

UnivateProperties_API/Model/Property/PropertyType.cs → UnivateProperties_API/Model/Properties/PropertyType.cs

-namespace UnivateProperties_API.Model.Property
+namespace UnivateProperties_API.Model.Properties
 {
     public class PropertyType : BaseEntity
     {

UnivateProperties_API/Model/Property/PropertyUserField.cs → UnivateProperties_API/Model/Properties/PropertyUserField.cs

 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace UnivateProperties_API.Model.Property
+namespace UnivateProperties_API.Model.Properties
 {
     public class PropertyUserField : BaseEntity
     {

UnivateProperties_API/Model/Property/UserDefinedField.cs → UnivateProperties_API/Model/Properties/UserDefinedField.cs

 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace UnivateProperties_API.Model.Property
+namespace UnivateProperties_API.Model.Properties
 {
     public class UserDefinedField : BaseEntity
     {

UnivateProperties_API/Model/Property/UserDefinedGroup.cs → UnivateProperties_API/Model/Properties/UserDefinedGroup.cs

 using System.Collections.Generic;
 
-namespace UnivateProperties_API.Model.Property
+namespace UnivateProperties_API.Model.Properties
 {
     public class UserDefinedGroup : BaseEntity
     {

UnivateProperties_API/Model/Users/Agency.cs

-using System.Collections.Generic;
+using Castle.MicroKernel.Registration;
+using System.Collections.Generic;
 
 namespace UnivateProperties_API.Model.Users
 {
         public string CompanyRegNumber { get; set; }
 
         public virtual ICollection<Agent> Agents { get; set; }
+        public virtual ICollection<Property> Properties { get; set; }
         #endregion Properties
     }
 }

UnivateProperties_API/Model/Users/Agent.cs

-using System.Collections.Generic;
+using Castle.MicroKernel.Registration;
+using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations.Schema;
 
 namespace UnivateProperties_API.Model.Users
         [ForeignKey("Agency")]
         public int? AgencyId { get; set; }
         public virtual Agency Agency { get; set; }
+
+        public virtual ICollection<Property> Properties { get; set; }
         #endregion Properties
     }
 }

UnivateProperties_API/Model/Users/Individual.cs

 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
+using UnivateProperties_API.Model.Misc;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Model.Users
 {
         #endregion Constructor
 
         #region Properties
-        
+        public string IdNumber { get; set; }
+        public string CompanyRegNumber { get; set; }
+        public string MaritalStatus { get; set; }
+        public int? AddressId { get; set; }
+        public string IncomeTaxNumber { get; set; }
+        public virtual Address Address { get; set; }
+
+        public virtual ICollection<Property> Properties { get; set; }
         #endregion Properties
     }
 }

UnivateProperties_API/Model/Users/Person.cs

 
         #region Properties
         [ForeignKey("User")]
-        public int UserId { get; set; }
+        public int? UserId { get; set; }
         public string Name { get; set; }
         public string Surname { get; set; }
         public string Email { get; set; }

UnivateProperties_API/Model/Users/User.cs

-namespace UnivateProperties_API.Model.Users
+using UnivateProperties_API.Helpers;
+
+namespace UnivateProperties_API.Model.Users
 {
     public class User : BaseEntity
     {
         #region Constructor
+        public User(string username, string password)
+        {
+            Username = username;
+
+            byte[] passwordHash, passwordSalt;
+            MyCommon.CreatePasswordHash(password, out passwordHash, out passwordSalt);
+
+            PasswordHash = passwordHash;
+            PasswordSalt = passwordSalt;
+        }
+
+        /// <summary>
+        /// Do not use when creating new user
+        /// </summary>
         public User()
         {
 

UnivateProperties_API/Repository/Properties/IPropertyImageRepository.cs

 using System.Collections.Generic;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

 using System;
 using System.Collections.Generic;
 using UnivateProperties_API.Containers.Property;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {
         List<PropertyDisplay> GetDisplay(string type, string propertyType, string province, string city, string suburb, string propType);
         List<PropertyDisplay> GetLatestDisplay();
         List<PropertyType> GetPropertyTypes(Func<PropertyType, bool> where);
+        List<PropertyList> GetPropertyList(Func<Property, bool> where);
     }
 }

UnivateProperties_API/Repository/Properties/IUserDefinedGroupRepository.cs

 using System.Collections.Generic;
 using UnivateProperties_API.Containers.Property;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {
     {
         List<Group> GetFieldList(string name);
 
+        List<Group> GetFieldList(string propertyType, string name, int propertyID);
+
         List<Group> GetFieldListByPropType(string propertyType);
     }
 }

UnivateProperties_API/Repository/Properties/PropertyImageRepository.cs

 using System.Collections.Generic;
 using System.Linq;
 using UnivateProperties_API.Context;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

 using System.Linq;
 using UnivateProperties_API.Containers.Property;
 using UnivateProperties_API.Context;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {
             {
                 if (pt.UsageType == PropertyUsageType.Residential)
                 {
+                    string type = dBContext.PropertyTypes.Find(item.PropertyTypeId).Description;
                     if (item.PropertyUserFields.Count > 0)
                     {
-                        string shortDesc = "{0} {1} {2}";
-                        string type = dBContext.PropertyTypes.Find(item.PropertyTypeId).Description;
+                        string shortDesc = "{0} {1} {2}";                        
                         UserDefinedField bedrooms = dBContext.UserDefinedFields.Where(u => u.FieldName == "Bedrooms").FirstOrDefault();
                         var udValue = item.PropertyUserFields.Where(u => u.UserDefinedFieldId == bedrooms.Id).FirstOrDefault();
                         if (udValue != null)
                         else
                             item.ShortDescription = string.Format(shortDesc, "", "", pt.Description).Trim();
                     }
+                    else
+                    {
+                        item.ShortDescription = type;
+                    }
                 }
                 else
                 {
                             select c.Description).FirstOrDefault(),
                     Suburb = (from s in dBContext.Suburbs
                               where s.Id == item.SuburbId
-                              select s.Description).FirstOrDefault()
-
+                              select s.Description).FirstOrDefault(),
+                    Price = item.Price,
+                    DateCreated = item.Created
                 };
 
                 if (!string.IsNullOrEmpty(display.Area) && display.Area.EndsWith("2"))
             List<Property> props = GetAll().OrderBy(x => x.Created).Take(3).ToList();
             return GetDisplayDetails(props);
         }
+
+        public List<PropertyList> GetPropertyList(Func<Property, bool> where)
+        {
+            var properties = Get(where);
+
+            List<PropertyList> list = new List<PropertyList>();
+
+            foreach (Property p in properties)
+            {
+                var prop = new PropertyList()
+                {
+                    Id = p.Id,
+                    Name = string.IsNullOrEmpty(p.PropertyName) ? p.ShortDescription : p.PropertyName,
+                    Price = string.Format("R {0:n}", p.Price),
+                    Publish = p.Published.ToString(),
+                    Type = dBContext.PropertyTypes.Find(p.PropertyTypeId)?.Description
+                };
+
+                prop.Size = (from u in dBContext.PropertyUserFields
+                             join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
+                             where u.PropertyId == p.Id
+                             && f.FieldName == "Floor Size"
+                             select u.Value).FirstOrDefault();
+
+                if (!string.IsNullOrEmpty(prop.Size) && prop.Size.EndsWith("2"))
+                {
+                    prop.Size = prop.Size.Substring(0, prop.Size.Length - 1) + "<sup>" + prop.Size.Last() + "</sup>";
+                }
+
+                list.Add(prop);
+            }
+                
+            return list;
+        }
     }
 }

UnivateProperties_API/Repository/Properties/PropertyTypeRepository.cs

 using System.Collections.Generic;
 using System.Linq;
 using UnivateProperties_API.Context;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {

UnivateProperties_API/Repository/Properties/PropertyUserFieldRepository.cs

 using System.Collections.Generic;
 using System.Linq;
 using UnivateProperties_API.Context;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {

UnivateProperties_API/Repository/Properties/UserDefinedFieldRepository.cs

 using System.Collections.Generic;
 using System.Linq;
 using UnivateProperties_API.Context;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {
 
         public List<UserDefinedField> Get(Func<UserDefinedField, bool> where)
         {
-            return dBContext.UserDefinedFields.Where(where).ToList();
+            return dBContext.UserDefinedFields.Where(where).OrderBy(x => x.Rank).ToList();
         }
 
         public List<UserDefinedField> GetAll()
         {
-            return dBContext.UserDefinedFields.ToList();
+            return dBContext.UserDefinedFields.OrderBy(x => x.Rank).ToList();
         }
 
         public UserDefinedField GetDetailed(Func<UserDefinedField, bool> first)

UnivateProperties_API/Repository/Properties/UserDefinedGroupRepository.cs

 using System.Linq;
 using UnivateProperties_API.Containers.Property;
 using UnivateProperties_API.Context;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Repository.Properties
 {
 
         public List<UserDefinedGroup> Get(Func<UserDefinedGroup, bool> where)
         {
-            return dBContext.UserDefinedGroups.Where(where).ToList();
+            return dBContext.UserDefinedGroups.Where(where).OrderBy(x => x.Rank).ToList();
         }
 
         public List<UserDefinedGroup> GetAll()
         {
-            return dBContext.UserDefinedGroups.ToList();
+            return dBContext.UserDefinedGroups.OrderBy(x => x.Rank).ToList();
         }
 
         public UserDefinedGroup GetDetailed(Func<UserDefinedGroup, bool> first)
             return FieldGroups;
         }
 
+        public List<Group> GetFieldList(string propertyType, string name, int propertyID)
+        {
+            List<Group> FieldGroups = GetFieldList(name);
+            if (name == "Property Overview")
+                FieldGroups = GetFieldList(name);
+            else
+                FieldGroups = GetFieldListByPropType(propertyType);
+
+            var savedValues = dBContext.PropertyUserFields.Where(x => x.PropertyId == propertyID).ToList();
+            foreach (Group group in FieldGroups)
+            {
+                foreach(GroupFields field in group.Fields)
+                {
+                    var item = savedValues.Find(x => x.UserDefinedFieldId == field.ID);
+                    if (item != null)
+                        field.Value = item.Value;
+                }
+            }
+
+            return FieldGroups;
+        }
+
         public List<Group> GetFieldListByPropType(string propertyType)
         {
             List<Group> FieldGroups = new List<Group>();

UnivateProperties_API/Repository/Users/AgentRepository.cs

 using System.Collections.Generic;
 using System.Linq;
 using UnivateProperties_API.Context;
+using UnivateProperties_API.Helpers;
 using UnivateProperties_API.Model.Users;
 
 namespace UnivateProperties_API.Repository.Users
 
         public Agent GetDetailed(Func<Agent, bool> first)
         {
+
             var item = _dbContext.Agents.FirstOrDefault(first);
             //AgentRepository account = new AgentRepository(_dbContext);
             //item = GetDetailedObject(item, account);
 
         public void Insert(Agent item)
         {
-            if (item.AgencyId != 0 && item.Agency == null)
-            {
-                AgencyRepository arepo = new AgencyRepository(_dbContext);
-                item.Agency = arepo.Get(a => a.Id == item.AgencyId).FirstOrDefault();
-            }
             _dbContext.Add(item);
             Save();
         }

UnivateProperties_API/Repository/Users/RegisterRepository.cs

 
             // check if username exists
             if (user == null)
-                return null;
+                throw new AppException("Username is incorrect");
 
             // check if password is correct
-            if (!VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
-                return null;
+            if (!MyCommon.VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
+                throw new AppException("Password is incorrect");
 
             // authentication successful
             return user;
                 throw new AppException("Username \"" + user.Username + "\" is already taken");
 
             byte[] passwordHash, passwordSalt;
-            CreatePasswordHash(password, out passwordHash, out passwordSalt);
+            MyCommon.CreatePasswordHash(password, out passwordHash, out passwordSalt);
 
             user.PasswordHash = passwordHash;
             user.PasswordSalt = passwordSalt;
                 throw new AppException("Individual \"" + individual.Username + "\" is already taken");
             byte[] passwordHash, passwordSalt;
 
-            CreatePasswordHash(individual.Password, out passwordHash, out passwordSalt);
+            MyCommon.CreatePasswordHash(individual.Password, out passwordHash, out passwordSalt);
+
+            User createUser = new User(individual.Username, individual.Password);
 
-            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()
             if (!string.IsNullOrWhiteSpace(password))
             {
                 byte[] passwordHash, passwordSalt;
-                CreatePasswordHash(password, out passwordHash, out passwordSalt);
+                MyCommon.CreatePasswordHash(password, out passwordHash, out passwordSalt);
 
                 user.PasswordHash = passwordHash;
                 user.PasswordSalt = passwordSalt;
         {
             _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/Startup.cs

 using System.Threading.Tasks;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Model.Communication;
-using UnivateProperties_API.Model.Property;
+using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Model.Region;
 using UnivateProperties_API.Model.Timeshare;
 using UnivateProperties_API.Model.Users;