Merge branch 'master' of http://192.168.6.188:3000/Provision/UnivatePropertiesAPI

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; }
+        public string Value { get; set; }                        
+        public int ItemID { get; set; }
         #endregion
     }
 }

UnivateProperties_API/Containers/Property/PropertyContainer.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace UnivateProperties_API.Containers.Property
+{
+    public class PropertyContainer : Model.Properties.Property
+    {
+        public int UserId { get; set; }
+        public string PropertyUsageType { get; set; } 
+    }
+}

UnivateProperties_API/Controllers/Properties/PropertyController.cs

             return new OkObjectResult(_Repo.GetDisplay());
         }
 
-        [HttpGet("{id}")]
-        public IActionResult Get(int id)
+        [HttpGet("getDetailed/{id}")]
+        public IActionResult GetDetailed(int id)
         {
-            return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
-        }          
+            return new OkObjectResult(_Repo.GetDetailed(id, true));
+        }
+
+        [HttpGet("getProperty/{id}")]
+        public IActionResult GetProperty(int id)
+        {
+            return new OkObjectResult(_Repo.GetDetailed(id, false));
+        }
 
         [HttpGet("latestProperties")]
         public IActionResult GetLatestProperties()
         }
 
         [HttpPost]
-        public IActionResult Post([FromBody] Property property)
+        public IActionResult Post([FromBody] PropertyContainer property)
         {
             using (var scope = new TransactionScope())
             {
         }
 
         [HttpPut]
-        public IActionResult Put([FromBody] Property property)
+        public IActionResult Put([FromBody] PropertyContainer property)
         {
             if (property != null)
             {

UnivateProperties_API/Model/Properties/Property.cs

         public int CityId { get; set; }
         public int ProvinceId { get; set; }
         public bool Published { get; set; }
+        public string VirtualTour { get; set; }
+        public string Video { get; set; }
         [ForeignKey("Status")]
         public int? StatusId { get; set; }
         [ForeignKey("Owner")]

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

         List<PropertyDisplay> GetLatestDisplay();
         List<PropertyType> GetPropertyTypes(Func<PropertyType, bool> where);
         List<PropertyList> GetPropertyList(string Type, int By);
+        void Insert(PropertyContainer items);
+        PropertyContainer GetDetailed(int id, bool detailed);
+        void Update(PropertyContainer item);
     }
 }

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

 using Microsoft.EntityFrameworkCore;
 using Newtonsoft.Json;
 using System;
-using System.IO;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using UnivateProperties_API.Containers.Property;
 using UnivateProperties_API.Containers.Timeshare;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Model.Logging;
 using UnivateProperties_API.Model.Properties;
-using System.Drawing;
 
 namespace UnivateProperties_API.Repository.Properties
 {
 
         public Property GetDetailed(Func<Property, bool> first)
         {
-            var property = dBContext.Properties.Include("Status").FirstOrDefault(first);
+            throw new NotImplementedException();            
+        }
+
+        public PropertyContainer GetDetailed(int id, bool detailed)
+        {
+            var property = dBContext.Properties.Include("Status").Where(p => p.Id == id).FirstOrDefault();            
             if (property != null)
             {
-                GetDetail(ref property);
+                return GetDetail(property, detailed);
             }
-            return property;
+            return null;
         }
 
         public List<Property> GetDetailedAll()
             return properties;
         }
 
-        private void GetDetail(ref Property property)
-        {
+        private PropertyContainer GetDetail(Property property, bool detailed)
+        {            
             int propID = property.Id;
             var propertyType = dBContext.PropertyTypes.Find(property.PropertyTypeId);
             property.Province = dBContext.Provinces.Find(property.ProvinceId);
             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)
+            if (detailed)
             {
-                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
-                        });
-                    }
+                var groups = (from g in dBContext.UserDefinedGroups
+                              where g.UsageType == propertyType.UsageType
+                              || g.UsageType == PropertyUsageType.Both
+                              orderby g.Rank
+                              select g).ToList();
 
-                    foreach (var val in groupFields)
+                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)
                     {
-                        var irem = new PropertyDetail()
+                        PropertyDetailGroup detailGroup = new PropertyDetailGroup()
                         {
-                            Name = val.FieldName,
-                            Description = val.Description
+                            GroupName = uGroup.Description,
+                            Values = new List<PropertyDetail>()
                         };
 
-                        detailGroup.Values.Add(irem);
+                        if (uGroup.Description == "Property Overview")
+                        {
+                            detailGroup.Values.Add(new PropertyDetail()
+                            {
+                                Name = "Property Type",
+                                Value = property.PropertyType.Description
+                            });
+                        }
 
-                        if ((val.FieldName == "Erf Size" || val.FieldName == "Floor Size") && val.Value.EndsWith("2"))
+                        foreach (var val in groupFields)
                         {
-                            irem.Value = val.Value.Substring(0, val.Value.Length - 1) + "<sup>" + val.Value.Last() + "</sup>";
+                            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;
                         }
-                        else
-                            irem.Value = val.Value;
-                    }
 
-                    property.DisplayData.Add(detailGroup);
+                        property.DisplayData.Add(detailGroup);
+                    }
                 }
             }
-        }
-
-        public void Insert(Property item)
-        {
-            PropertyType pt = dBContext.PropertyTypes.Find(item.PropertyTypeId);
-            if (pt != null)
+            else
             {
-                if (pt.UsageType == PropertyUsageType.Residential)
-                {
-                    string type = dBContext.PropertyTypes.Find(item.PropertyTypeId).Description;
-                    if (item.PropertyUserFields.Count > 0)
-                    {
-                        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)
-                            item.ShortDescription = string.Format(shortDesc, udValue.Value, "Bedroom", pt.Description).Trim();
-                        else
-                            item.ShortDescription = string.Format(shortDesc, "", "", pt.Description).Trim();
-                    }
-                    else
-                    {
-                        item.ShortDescription = type;
-                    }
-                }
-                else
-                {
-                    item.ShortDescription = pt.Description;
-                }
+                if (!string.IsNullOrEmpty(property.Video))
+                    property.Video = string.Format("https://www.youtube.com/watch?v={0}", property.Video);
             }
 
-            var images = item.PropertyImages;
-            var fields = item.PropertyUserFields;
+            var propertyDetails = new PropertyContainer();
 
-            item.PropertyImages = null;
-            item.PropertyUserFields = null;
-
-            dBContext.Properties.Add(item);
-            Save();
-
-            if (images != null)
+            foreach (string prop in property.GetAllProperties())
             {
-                var lastID = (from p in dBContext.PropertyImages
-                              orderby p.Id descending
-                              select p.Id).FirstOrDefault();
+                if (prop != "Item")
+                    propertyDetails[prop] = property[prop];
+            }            
 
-                bool saveFiles = false;
-                var loc = dBContext.Location.FirstOrDefault().PropertyImageLocation;
-                if (!string.IsNullOrEmpty(loc))
-                {
-                    saveFiles = true;
-                    loc += string.Format("\\{0}", item.Id);
-                    if (Directory.Exists(loc))
-                    {
-                        Directory.CreateDirectory(loc);
-                    }
-                }
-                
-                foreach (PropertyImage image in images)
-                {
-                    lastID++;
-                    image.Id = lastID;
-                    image.PropertyId = item.Id;
-                    if (saveFiles)
-                    {
-                        string path = ImageFormatter.Base64ToImage(image.Image, loc, lastID.ToString());
-                        image.Image = path;
-                    }
-                    dBContext.PropertyImages.Add(image);
-                    Save();
-                }
-            }
+            propertyDetails.PropertyUsageType = propertyType.UsageType == PropertyUsageType.Commercial ? "Commercial" : "Residential";
 
-            if (fields != null)
-            {
-                var lastID = (from p in dBContext.PropertyUserFields
-                              orderby p.Id descending
-                              select p.Id).FirstOrDefault();
+            if (property.OwnerId > 0)
+                propertyDetails.UserId = (dBContext.Individuals.Where(p => p.Id == property.OwnerId).FirstOrDefault().UserId).Value;
+            if (property.AgentId > 0)
+                propertyDetails.UserId = (dBContext.Agents.Where(p => p.Id == property.AgentId).FirstOrDefault().UserId).Value;
 
-                foreach (PropertyUserField field in fields)
-                {
-                    lastID++;
-                    field.Id = lastID;
-                    field.PropertyId = item.Id;
-                    dBContext.PropertyUserFields.Add(field);
-                    Save();
-                }
-            }
+            return propertyDetails;
+        }
+
+        public void Insert(Property item)
+        {
+            throw new NotImplementedException();
         }
 
         public void Insert(IEnumerable<Property> items)
 
         public void Remove(Property item)
         {
-            dBContext.Properties.Remove(item);
+            item.IsDeleted = true;
             Save();
         }
 
         {
             foreach (var item in items)
             {
-                dBContext.Properties.Remove(item);
+                item.IsDeleted = true;
             }
             Save();
         }
 
         public void Update(Property item)
         {
+            if (item.Video.StartsWith("http"))
+                item.Video = item.Video.Replace("https://www.youtube.com/watch?v=", "");
+
             dBContext.Entry(item).State = EntityState.Modified;
             Save();
         }
 
+        public void Update(PropertyContainer item)
+        {
+            if (item.Video.StartsWith("http"))
+                item.Video = item.Video.Replace("https://www.youtube.com/watch?v=", "");
+
+            var property = new Property();
+            foreach (string prop in property.GetAllProperties())
+            {
+                if (prop != "Item")
+                    property[prop] = item[prop];
+            }
+
+            dBContext.Entry(property).State = EntityState.Modified;
+            Save();
+        }
+
         public List<PropertyDisplay> GetDisplay()
         {
             List<Property> props = GetAll();
                                          select p.UsageType.ToString()).FirstOrDefault()
                 };
 
-                if (!display.DisplayImage.StartsWith("data:image"))
+                if (display.DisplayImage != null && !display.DisplayImage.StartsWith("data:image"))
                 {
                     display.DisplayImage = ImageFormatter.ImageToBase64(display.DisplayImage);
                 }
         {
             // Not sure if properties need it
             return 0;
-        }       
+        }
+
+        public void Insert(PropertyContainer items)
+        {
+            Property property = new Property();
+
+            PropertyType pt = dBContext.PropertyTypes.Find(items.PropertyTypeId);
+            if (pt != null)
+            {
+                if (pt.UsageType == PropertyUsageType.Residential)
+                {
+                    string type = dBContext.PropertyTypes.Find(items.PropertyTypeId).Description;
+                    if (items.PropertyUserFields.Count > 0)
+                    {
+                        string shortDesc = "{0} {1} {2}";
+                        UserDefinedField bedrooms = dBContext.UserDefinedFields.Where(u => u.FieldName == "Bedrooms").FirstOrDefault();
+                        var udValue = items.PropertyUserFields.Where(u => u.UserDefinedFieldId == bedrooms.Id).FirstOrDefault();
+                        if (udValue != null)
+                            items.ShortDescription = string.Format(shortDesc, udValue.Value, "Bedroom", pt.Description).Trim();
+                        else
+                            items.ShortDescription = string.Format(shortDesc, "", "", pt.Description).Trim();
+                    }
+                    else
+                    {
+                        items.ShortDescription = type;
+                    }
+                }
+                else
+                {
+                    items.ShortDescription = pt.Description;
+                }
+            }
+
+            var images = items.PropertyImages;
+            var fields = items.PropertyUserFields;
+
+            items.PropertyImages = null;
+            items.PropertyUserFields = null;
+
+            var individual = dBContext.Individuals.Where(i => i.UserId == items.UserId).FirstOrDefault();
+            var agent = dBContext.Agents.Where(a => a.UserId == items.UserId).FirstOrDefault();            
+
+            foreach( string prop in property.GetAllProperties())
+            {
+                if (prop != "Item")
+                    property[prop] = items[prop];
+            }
+
+            if (individual != null)
+                property.OwnerId = individual.Id;
+            if (agent != null)
+            {
+                property.AgencyId = agent.AgencyId;
+                property.AgentId = agent.Id;
+            }
+
+            property.Video = property.Video.Replace("https://www.youtube.com/watch?v=", "");
+
+            dBContext.Properties.Add(property);
+            Save();
+
+            if (images != null)
+            {
+                var lastID = (from p in dBContext.PropertyImages
+                              orderby p.Id descending
+                              select p.Id).FirstOrDefault();
+
+                bool saveFiles = false;
+                var loc = dBContext.Location.FirstOrDefault().PropertyImageLocation;
+                if (!string.IsNullOrEmpty(loc))
+                {
+                    saveFiles = true;
+                    loc += string.Format("\\{0}", property.Id);
+                    if (Directory.Exists(loc))
+                    {
+                        Directory.CreateDirectory(loc);
+                    }
+                }
+
+                foreach (PropertyImage image in images)
+                {
+                    lastID++;
+                    image.Id = lastID;
+                    image.PropertyId = property.Id;
+                    if (saveFiles)
+                    {
+                        string path = ImageFormatter.Base64ToImage(image.Image, loc, lastID.ToString());
+                        image.Image = path;
+                    }
+                    dBContext.PropertyImages.Add(image);
+                    Save();
+                }
+            }
+
+            if (fields != null)
+            {
+                var lastID = (from p in dBContext.PropertyUserFields
+                              orderby p.Id descending
+                              select p.Id).FirstOrDefault();
+
+                foreach (PropertyUserField field in fields)
+                {
+                    lastID++;
+                    field.Id = lastID;
+                    field.PropertyId = property.Id;
+                    dBContext.PropertyUserFields.Add(field);
+                    Save();
+                }
+            }
+        }        
     }
 }

UnivateProperties_API/Repository/Properties/UserDefinedGroupRepository.cs

                 {
                     var item = savedValues.Find(x => x.UserDefinedFieldId == field.ID);
                     if (item != null)
+                    {
                         field.Value = item.Value;
+                        field.ItemID = item.Id;
+                    }
                 }
             }