Changes made to get edit working

UnivateProperties_API/Containers/Property/PropertyDetail.cs

         public string Description { get; set; }
         #endregion 
     }
-
-    public class PropertyEditDetails
-    {
-        #region Properties
-        public string PropertyType { get; set; }
-        public string SaleType { 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/Controllers/Properties/PropertyController.cs

 
 namespace UnivateProperties_API.Controllers.Properties
 {
-    [Route("Property/[controller]")]
+    [Route("api/[controller]")]
     [ApiController]
     public class PropertyController : ControllerBase
     {
 
                 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
         [HttpGet("GetEditDisplay/{id}")]
         public IActionResult GetEditDisplay(int id)
         {
-            return new OkObjectResult(_Repo.GetEditDisplay(x => x.Id == id));
+            return new OkObjectResult(_Repo.GetPropertyList(x => x.Id == id));
         }
         #endregion
 

UnivateProperties_API/Controllers/Properties/PropertyFieldsController.cs

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

UnivateProperties_API/Controllers/Properties/PropertyImageController.cs

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

UnivateProperties_API/Controllers/Properties/PropertyTypeController.cs

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

UnivateProperties_API/Controllers/Properties/PropertyUserFieldController.cs

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

UnivateProperties_API/Controllers/Properties/UserDefinedFieldController.cs

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

UnivateProperties_API/Controllers/Properties/UserDefinedGroupController.cs

 
 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/Model/Property/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
 {
         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/Users/Agency.cs

         public string CompanyRegNumber { get; set; }
 
         public virtual ICollection<Agent> Agents { get; set; }
+        public virtual ICollection<Property.Property> Properties { get; set; }
         #endregion Properties
     }
 }

UnivateProperties_API/Model/Users/Agent.cs

         [ForeignKey("Agency")]
         public int? AgencyId { get; set; }
         public virtual Agency Agency { get; set; }
+
+        public virtual ICollection<Property.Property> Properties { get; set; }
         #endregion Properties
     }
 }

UnivateProperties_API/Model/Users/Individual.cs

         #endregion Constructor
 
         #region Properties
-        
+        public virtual ICollection<Property.Property> Properties { get; set; }
         #endregion Properties
     }
 }

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

         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);
-        PropertyEditDetails GetEditDisplay(Func<Property, bool> where);
+        List<PropertyList> GetPropertyList(Func<Property, bool> where);
     }
 }

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

             {
                 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"))
             return GetDisplayDetails(props);
         }
 
-        public PropertyEditDetails GetEditDisplay(Func<Property, bool> where)
+        public List<PropertyList> GetPropertyList(Func<Property, bool> where)
         {
-            var property = dBContext.Properties.Include("PropertyType").Where(where).FirstOrDefault();
-            PropertyEditDetails details = new PropertyEditDetails();
+            var properties = Get(where);
 
-            if (property != null)
+            List<PropertyList> list = new List<PropertyList>();
+
+            foreach (Property p in properties)
             {
-                details.SaleType = property.IsSale ? "Sale" : "Rental";
-                details.PropertyType = property.PropertyType.UsageType.ToString();
-            }
+                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
+                };
 
-            return details;
+                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;
         }
     }
 }