commit merge

UnivateProperties_API/Containers/Property/ImageFormatter.cs

 
         public static string ImageToBase64(string Path)
         {
-            using (Image image = Image.FromFile(Path))
+            if (File.Exists(Path))
             {
-                using (MemoryStream m = new MemoryStream())
+                using (Image image = Image.FromFile(Path))
                 {
-                    image.Save(m, image.RawFormat);
-                    byte[] imageBytes = m.ToArray();
+                    using (MemoryStream m = new MemoryStream())
+                    {
+                        image.Save(m, image.RawFormat);
+                        byte[] imageBytes = m.ToArray();
 
-                    string base64String = Convert.ToBase64String(imageBytes);
+                        string base64String = Convert.ToBase64String(imageBytes);
 
-                    if (Path.EndsWith(".jpg") || Path.EndsWith(".jpeg"))
-                        base64String = "data:image/jpeg;base64," + base64String;
-                    if (Path.EndsWith(".gif"))
-                        base64String = "data:image/gif;base64," + base64String;
-                    if (base64String.EndsWith(".png"))
-                        base64String = "data:image/png;base64," + base64String;
+                        if (Path.EndsWith(".jpg") || Path.EndsWith(".jpeg"))
+                            base64String = "data:image/jpeg;base64," + base64String;
+                        if (Path.EndsWith(".gif"))
+                            base64String = "data:image/gif;base64," + base64String;
+                        if (base64String.EndsWith(".png"))
+                            base64String = "data:image/png;base64," + base64String;
 
-                    return base64String;
+                        return base64String;
+                    }
                 }
             }
+            else
+                return "";
         }
     }
 }

UnivateProperties_API/Containers/Property/PropertyContainer.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using UnivateProperties_API.Model.Properties;
 
 namespace UnivateProperties_API.Containers.Property
 {
         public string Image { get; set;  }
         public bool IsDefault { get; set; }
     }
+
+    public class PropertyImageContainer
+    {
+        public int PropertyId { get; set; }
+        public List<PropertyImage> Images { get; set; }
+    }
 }

UnivateProperties_API/Containers/Property/PropertyList.cs

         public string SaleType { get; set; }
         public string Publish { get; set; }
         public string Status { get; set; }
+        public string CarouselDescription { get; set; }
         #endregion
     }
 }

UnivateProperties_API/Containers/Regions/SuburbSearch.cs

     public class SuburbSearch
     {
         public int Id { get; set; }
+        public string Province { get; set; }
+        public string City { get; set; }
         public string Suburb { get; set; }
         public string Display { get; set; }
     }

UnivateProperties_API/Context/DataContext.cs

             modelBuilder.Entity<BidItem>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
             modelBuilder.Entity<ProcessFlow>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
             modelBuilder.Entity<Template>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<Carousel>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
             modelBuilder.Entity<PlaceHolder>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
         }
 

UnivateProperties_API/Controllers/Misc/CarouselController.cs

         [HttpGet("{id}")]
         public IActionResult Get(int id)
         {
-            return new OkObjectResult(_Repo.GetDetailed(x => x.Id == id));
+            return new OkObjectResult(_Repo.GetCarousel(id));
         }        
 
         [HttpPost]

UnivateProperties_API/Controllers/Properties/PropertyController.cs

         [HttpPost]
         public IActionResult Post([FromBody] PropertyContainer property)
         {
-            using (var scope = new TransactionScope())
+            using (var scope = new TransactionScope(TransactionScopeOption.Suppress))
             {
                 _Repo.Insert(property);
-                scope.Complete();
+                scope.Complete();                
                 return CreatedAtAction(nameof(Get), new { id = property.Id }, property);
-            }
-        }       
+            }            
+        }      
 
         [HttpPut]
         public IActionResult Put([FromBody] PropertyContainer property)
         {
             if (property != null)
             {
-                using (var scope = new TransactionScope())
+                using (var scope = new TransactionScope(TransactionScopeOption.Suppress))
                 {
                     _Repo.Update(property);
                     scope.Complete();

UnivateProperties_API/Repository/Misc/CarouselRepository.cs

 using Microsoft.EntityFrameworkCore;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using UnivateProperties_API.Containers.Misc;
 using UnivateProperties_API.Containers.Property;
 
         public void Insert(Carousel item)
         {
-            dBContext.Carousel.Add(item);
+            string image = item.Image;
+            item.Image = "";
+            dBContext.Add(item);
             Save();
+
+            bool saveFiles = false;
+            var loc = dBContext.Location.FirstOrDefault().PropertyImageLocation;
+            var lastID = item.Id;
+            item.Id = lastID;
+            if (!string.IsNullOrEmpty(loc))
+            {
+                saveFiles = true;
+                loc = loc.Replace("Properties", "Carousel");
+                if (Directory.Exists(loc))
+                {
+                    Directory.CreateDirectory(loc);
+                }
+            }
+            if (saveFiles)
+            {
+                string path = ImageFormatter.Base64ToImage(image, loc, lastID.ToString());
+                item.Image = path;
+            }
+
+            Update(item);
+            
         }
 
         public void Insert(IEnumerable<Carousel> items)
             var CarouselList = dBContext.Carousel.ToList();
 
             foreach (var item in CarouselList)
-            {
+            {                
                 if (!string.IsNullOrEmpty(item.Image) && !item.Image.StartsWith("data:image"))
                     item.Image = ImageFormatter.ImageToBase64(item.Image);
 
                 var carItem = new CarouselList()
                 {
+                    Id = item.Id,
                     Image = item.Image,
                     Header = item.Header
                 };
 
             return list;
         }
+
+        public CarouselList GetCarousel(int id)
+        {
+            var carousel = dBContext.Carousel.Where(c => c.Id == id).FirstOrDefault();
+
+            CarouselList item = new CarouselList();
+            if (carousel != null)
+            {
+                foreach (string prop in carousel.GetAllProperties())
+                {
+                    if (prop != "Item" && prop != "Display")
+                        item[prop] = carousel[prop];
+                }
+
+                if (item.PropertyId > 0)
+                {
+                    var property = dBContext.Properties.Include("Province").Include("City").Include("Suburb").Where(p => p.Id == item.PropertyId).FirstOrDefault();
+                    item.Address = string.Format("{0}, {1} <br/>{2}", property.Suburb.Description, property.City.Description, property.AddressLine3);
+                    item.IsProperty = true;
+                }
+                if (item.TimeshareId > 0)
+                {
+                    var timeshare = dBContext.Weeks.Where(t => t.Id == item.TimeshareId).FirstOrDefault();
+                    item.Bedrooms = timeshare.Bedrooms;
+                    item.Sleeps = timeshare.MaxSleep;
+                    item.Arrival = timeshare.ArrivalDate;
+                    item.Departure = timeshare.DepartureDate;
+                    item.IsProperty = false;
+                }
+            }
+
+            return item;
+        }
     }
 }

UnivateProperties_API/Repository/Misc/ICarouselRepository.cs

     public interface ICarouselRepository : IRepository<Carousel>
     {
         List<CarouselList> GetCarouselItems();
+        CarouselList GetCarousel(int id);
     }
 }

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

         void Insert(PropertyContainer items);
         PropertyContainer GetDetailed(int id, bool detailed);
         void Update(PropertyContainer item);
-        bool MayEdit(int id);        
+        bool MayEdit(int id);
+        void InsertImages(int propertyID, List<PropertyImage> Images);
+        void InsertFields(int propertyID, List<PropertyUserField> Fields);
     }
 }

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

 
         public List<PropertyDisplay> GetLatestDisplay()
         {
-            List<Property> props = GetAll().OrderBy(x => x.Created).Take(3).ToList();
+            List<Property> props = GetAll().OrderByDescending(x => x.Created).Take(3).ToList();
             return GetDisplayDetails(props);
         }
 
             if (Type.ToUpper() == "MY")
             {                
                 if (individual != null)
-                    properties = Get(x => x.OwnerId == individual.Id);
+                    properties = dBContext.Properties.Include("City").Include("Suburb").Where(x => x.OwnerId == individual.Id).ToList();
                 if (agent != null)
-                    properties = Get(x => x.AgentId == agent.Id);
+                    properties = dBContext.Properties.Include("City").Include("Suburb").Where(x => x.AgentId == agent.Id).ToList();
             }
-            else
+            else if (Type.ToUpper() == "ADMIN")
             {
                 if (individual != null)
-                    properties = Get(x => x.OwnerId == individual.Id);
+                    properties = dBContext.Properties.Include("City").Include("Suburb").Where(x => x.OwnerId == individual.Id).ToList();
                 if (agent != null)
-                    properties = Get(x => x.AgencyId == agent.AgencyId);
+                    properties = dBContext.Properties.Include("City").Include("Suburb").Where(x => x.AgencyId == agent.AgencyId).ToList();
+            }
+            else if (Type.ToUpper() == "SUPERADMIN")
+            {
+                properties = dBContext.Properties.Include("City").Include("Suburb").ToList();
             }
             
             List<PropertyList> list = new List<PropertyList>();
                     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
+                    Type = dBContext.PropertyTypes.Find(p.PropertyTypeId)?.Description,
+                    CarouselDescription = string.Format("{0}, {1} <br/>{2}", p.Suburb.Description, p.City.Description, p.AddressLine3)
                 };
 
                 prop.Size = (from u in dBContext.PropertyUserFields
 
             foreach( string prop in property.GetAllProperties())
             {
-                if (prop != "Item")
+                if (prop != "Item" && prop != "Display")
                     property[prop] = items[prop];
             }
 
 
             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();
+                var lastID = dBContext.GetMaxID("PropertyImages");
 
                 bool saveFiles = false;
                 var loc = dBContext.Location.FirstOrDefault().PropertyImageLocation;
                     }
                 }
 
+                property.PropertyImages = new List<PropertyImage>();
                 foreach (PropertyImage image in images)
                 {
                     lastID++;
                         string path = ImageFormatter.Base64ToImage(image.Image, loc, lastID.ToString());
                         image.Image = path;
                     }
-                    dBContext.PropertyImages.Add(image);
-                    Save();
+                    property.PropertyImages.Add(image);
                 }
             }
 
             if (fields != null)
             {
-                var lastID = (from p in dBContext.PropertyUserFields
-                              orderby p.Id descending
-                              select p.Id).FirstOrDefault();
-
+                var lastID = dBContext.GetMaxID("PropertyUserFields");
+                property.PropertyUserFields = new List<PropertyUserField>();
                 foreach (PropertyUserField field in fields)
                 {
                     lastID++;
                     field.Id = lastID;
                     field.PropertyId = property.Id;
-                    dBContext.PropertyUserFields.Add(field);
-                    Save();
+                    property.PropertyUserFields.Add(field);
                 }
             }
+
+            dBContext.Properties.Add(property);
+            Save();
+
+            items.Id = property.Id;            
         }
 
         public bool MayEdit(int id)
                                select b).FirstOrDefault();
 
             return (hasBidItems == null) ? true : false;
-        }                
+        }
+
+        public void InsertImages(int propertyID, List<PropertyImage> Images)
+        {
+            if (Images != null)
+            {
+                var lastID = dBContext.GetMaxID("PropertyImages");
+
+                bool saveFiles = false;
+                var loc = dBContext.Location.FirstOrDefault().PropertyImageLocation;
+                if (!string.IsNullOrEmpty(loc))
+                {
+                    saveFiles = true;
+                    loc += string.Format("\\{0}", propertyID);
+                    if (Directory.Exists(loc))
+                    {
+                        Directory.CreateDirectory(loc);
+                    }
+                }
+
+                foreach (PropertyImage image in Images)
+                {
+                    lastID++;
+                    image.Id = lastID;
+                    image.PropertyId = propertyID;
+                    if (saveFiles)
+                    {
+                        string path = ImageFormatter.Base64ToImage(image.Image, loc, lastID.ToString());
+                        image.Image = path;
+                    }
+                    dBContext.PropertyImages.Add(image);
+                    Save();
+                }
+            }
+        }
+
+        public void InsertFields(int propertyID, List<PropertyUserField> Fields)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

UnivateProperties_API/Repository/Region/SuburbRepository.cs

 
         public List<SuburbSearch> GetSearchList()
         {
-            var suburbs = dBContext.Suburbs.Include("City").ToList();
+            var suburbs = dBContext.Suburbs.Include("City").Include("City.Province").ToList();
             List<SuburbSearch> searchList = new List<SuburbSearch>();
             
             foreach (var sub in suburbs)
             {
                 searchList.Add(new SuburbSearch()
-                {
-                    Id = sub.Id,
+                {                       
+                    Province = sub.City.Province.Description,
+                    City = sub.City.Description,
                     Suburb = sub.Description,
                     Display = string.Format("{0} - {1}", sub.Description, sub.City.Description)
                 });
             }
 
-            return searchList;
+            var cities = dBContext.Cities.Include("Province").ToList();
+            foreach(var city in cities)
+            {
+                searchList.Add(new SuburbSearch()
+                {                    
+                    Province = city.Province.Description,
+                    City = city.Description,
+                    Suburb = "",
+                    Display = string.Format("{0}", city.Description)
+                });
+            }
+
+            return searchList.OrderBy(s => s.City).ThenBy(s => s.Suburb).ToList();
         }
 
         public List<Suburb> GetByProperty(int propertyId)