Fixes made to the prop edit

UnivateProperties_API/Containers/Property/PropertyContainer.cs

 {
     public class PropertyContainer : Model.Properties.Property
     {        
+        public string DateAvailableString { get; set; }
         public string StatusString { get; set; }
         public string SalesTypeString { get; set; }
         public int UserId { get; set; }

UnivateProperties_API/Containers/Property/PropertyDisplay.cs

         public string Province { get; set; }
         public string City { get; set; }
         public string Suburb { get; set; }
+        public string PropertyReference { get; set; }
         public string DisplayImage { get; set; }
         public decimal Price { get; set; }        
         public DateTime DateCreated { get; set; }

UnivateProperties_API/Controllers/Properties/PropertyController.cs

             return new OkObjectResult(_Repo.GetLatestDisplay());
         }
 
+        [HttpGet("latestProperties/{type}")]
+        public IActionResult GetLatestProperties(string type)
+        {
+            return new OkObjectResult(_Repo.GetLatestDisplay(type));
+        }
+
         [HttpGet("GetPropertyList/{by}")]
         public IActionResult SearchBy(int by)
         {

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

         List<PropertyDisplay> GetDisplay(Func<Property, bool> where);
         List<PropertyDisplay> GetDisplay(PropertySearch search);        
         List<PropertyDisplay> GetLatestDisplay();
+        List<PropertyDisplay> GetLatestDisplay(string type);
         List<PropertyType> GetPropertyTypes(Func<PropertyType, bool> where);
         List<PropertyList> GetPropertyList(int By);
         List<PropertyList> GetPropertyList();

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

 
         public List<Property> GetAll()
         {
-            var properties = dBContext.Properties.ToList();
+            var properties = dBContext.Properties.Include("PropertyType").ToList();
             return properties;
         }
 
                 propertyDetails.UserId = (dBContext.Agents.Where(p => p.Id == property.AgentId).FirstOrDefault().UserId).Value;
 
             propertyDetails.NewImages = new List<NewImage>();
+            propertyDetails.DateAvailableString = string.Format("{0:yyyy-MM-dd}", property.DateAvailable);
 
             return propertyDetails;
         }
                 property.StatusId = dBContext.Status.Where(s => s.Description == item.StatusString && s.StatusType == StatusType.Property).FirstOrDefault()?.Id;
             }
 
-            dBContext.Entry(property).State = EntityState.Modified;            
+            if (!string.IsNullOrEmpty(item.DateAvailableString))
+            {
+                property.DateAvailable = DateTime.Parse(item.DateAvailableString);
+            }
+
+            dBContext.Entry(property).State = EntityState.Modified;
+            Save();
 
             #region Insert New UDFs
-          
+
             foreach (var propGroup in item.PropertyFields)
             {
                 foreach (var field in propGroup.Fields)
                                 Value = field.Value
                             };
                             dBContext.Add(propField);
+                            Save();
                         }
                         else
                         {
                             propField.Value = field.Value;
                             dBContext.Entry(propField).State = EntityState.Modified;
+                            Save();
                         }
                     }                    
                 }
             }
             #endregion
 
-            #region Update Images            
+            #region Update Images   
+            //property.PropertyImages = new List<PropertyImage>();
 
-            if (item.NewImages != null)
+            if (item.PropertyImages != null)
             {
-                var imgList = dBContext.PropertyImages.Where(p => p.PropertyId == property.Id).ToList();
-                foreach (var image in imgList)
+                foreach (var propImg in item.PropertyImages)
                 {
-                    dBContext.Remove(image);
+                    var image = dBContext.PropertyImages.Where(pi => pi.Id == propImg.Id).FirstOrDefault();
+                    if (image != null)
+                    {
+                        if (propImg.IsDeleted)
+                            dBContext.PropertyImages.Remove(image);
+                        else
+                        {
+                            image.IsDefault = propImg.IsDefault;
+                            dBContext.Entry(image).State = EntityState.Modified;
+                            Save();
+                            //property.PropertyImages.Add(image);
+                        }
+                    }
                 }
+            }
 
+            if (item.NewImages != null)
+            {                
                 bool saveFiles = false;
                 var loc = dBContext.Location.FirstOrDefault()?.PropertyImageLocation;
                 if (!string.IsNullOrEmpty(loc))
                     }
                 }
 
-                property.PropertyImages = new List<PropertyImage>();
+                             
                 var lastID = dBContext.PropertyImages.Max(i => i.Id) + 1;
                 foreach (var image in item.NewImages)
                 {
                         string path = ImageFormatter.Base64ToImage(propImage.Image, loc, lastID.ToString());
                         propImage.Image = path;
                     }
-                    property.PropertyImages.Add(propImage);
-                    lastID++;
+
+                    var exists = dBContext.PropertyImages.Where(pi => pi.Image == propImage.Image && pi.PropertyId == property.Id).FirstOrDefault();
+                    if (exists == null)
+                    {
+                        //property.PropertyImages.Add(propImage);
+                        dBContext.PropertyImages.Add(propImage);
+                        Save();
+                        lastID++;
+                    }                                        
                 }
             }
 
             {
                 PropertyDisplay display = new PropertyDisplay
                 {
+                    PropertyReference = item.PropertyRef,
                     DateAvailable = item.DateAvailable,
                     Available = item.DateAvailable.Date > DateTime.Now.Date ? string.Format("Available form: {0: dd MMM yyyy}", item.DateAvailable) : "Available Now",
                     Id = item.Id,
                     PropertyUsageType = (from p in dBContext.PropertyTypes
                                          where p.Id == item.PropertyTypeId
                                          select p.UsageType.ToString()).FirstOrDefault(),
-                    HasPendingOffer = !MayEdit(item.Id)
-                };
+                    HasPendingOffer = false
+                };                
+
+                if (item.StatusId != null)
+                {
+                    var status = dBContext.Status.Where(s => s.Id == item.StatusId).FirstOrDefault();
+                    if (status.Description.ToUpper() == "OFFER PENDING")
+                        display.HasPendingOffer = true;                    
+                }
 
                 if (display.DisplayImage != null && !display.DisplayImage.StartsWith("data:image"))
                 {
             return GetDisplayDetails(props);
         }
 
+        public List<PropertyDisplay> GetLatestDisplay(string PropertyType)
+        {
+            var type = PropertyUsageType.Both;
+            switch (PropertyType.ToUpper())
+            {
+                case "RESIDENTIAL":
+                    type = PropertyUsageType.Residential;
+                    break;
+                case "COMMERCIAL":
+                    type = PropertyUsageType.Commercial;
+                    break;
+            }
+
+            List<Property> props = dBContext.Properties.Include("PropertyType").Where(x => x.Published && x.PropertyType.UsageType == type).OrderByDescending(x => x.DatePublished).Take(4).ToList();
+            return GetDisplayDetails(props);
+        }
+
         public List<PropertyList> GetPropertyList(int By)
         {
             List<Property> properties = new List<Property>();