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

UnivateProperties_API/Containers/Property/ImageFormatter.cs

+using System;
+using System.Drawing;
+using System.IO;
+
+namespace UnivateProperties_API.Containers.Property
+{
+    public class ImageFormatter
+    {
+        public static string Base64ToImage(string binData, string path, string name)
+        {
+            string extention = ".jpg";
+            if (binData.StartsWith("data:image/gif;base64,"))
+            {
+                extention = ".gif";
+                binData = binData.Replace("data:image/gif;base64,", "");
+            }
+            if (binData.StartsWith("data:image/jpeg;base64,"))
+            {
+                extention = ".jpg";
+                binData = binData.Replace("data:image/jpeg;base64,", "");
+            }
+            if (binData.StartsWith("data:image/png;base64,"))
+            {
+                extention = ".png";
+                binData = binData.Replace("data:image/png;base64,", "");
+            }
+
+            if (!Directory.Exists(path))
+                Directory.CreateDirectory(path);
+
+            string filePath = string.Format(@"{0}\{1}{2}", path, name, extention);
+            File.WriteAllBytes(filePath, Convert.FromBase64String(binData));
+            return filePath;
+        }
+
+        public static string ImageToBase64(string Path)
+        {
+            using (Image image = Image.FromFile(Path))
+            {
+                using (MemoryStream m = new MemoryStream())
+                {
+                    image.Save(m, image.RawFormat);
+                    byte[] imageBytes = m.ToArray();
+
+                    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;
+
+                    return base64String;
+                }
+            }
+        }
+    }
+}

UnivateProperties_API/Containers/Property/PropertyList.cs

         public int Id { get; set; }
         public string Size { get; set; }
         public string Price { get; set; }
+        public string UsageType { get; set;  }
         public string Type { get; set; }
+        public string SaleType { get; set; }
         public string Publish { get; set; }
         public string Status { get; set; }
         #endregion

UnivateProperties_API/Context/DataContext.cs

 
         #region Logs
         public DbSet<SearchLog> SearchLogs { get; set; }
-        #endregion 
+        #endregion
+
+        #region Misc
+        public DbSet<Location> Location { get; set; }
+        #endregion
 
         public override int SaveChanges()
         {

UnivateProperties_API/Controllers/Properties/PropertyController.cs

         }
 
         [HttpGet("{type}/{by}")]
-        public IActionResult SearchBy(string type, string by)
+        public IActionResult SearchBy(string type, int by)
         {
-            PropertyUsageType pType = PropertyUsageType.Both;
-            switch (type.ToUpper())
-            {
-                case "RESIDENTIAL":
-                    pType = PropertyUsageType.Residential;
-                    break;
-                case "COMMERCIAL":
-                    pType = PropertyUsageType.Commercial;
-                    break;
-            }
-
-            if (pType != PropertyUsageType.Both)
-            {
-                List<int> proptypeIds = (from pt in _Repo.GetPropertyTypes(p => p.UsageType == pType)
-                                         select pt.Id).ToList();
-
-                if (string.IsNullOrEmpty(by) || by.ToUpper() == "ALL")
-                {
-                    return new OkObjectResult(_Repo.GetPropertyList(x => proptypeIds.Contains(x.PropertyTypeId)));
-                }
-                else
-                {
-                    //Needs to change to search on individule/Agent
-                    return new OkObjectResult(_Repo.GetPropertyList(x => proptypeIds.Contains(x.PropertyTypeId)));
-                }
-            }
-            else
-                return new NoContentResult();
-        }
-
-        [HttpGet("GetEditDisplay/{id}")]
-        public IActionResult GetEditDisplay(int id)
-        {
-            return new OkObjectResult(_Repo.GetPropertyList(x => x.Id == id));
+            return new OkObjectResult(_Repo.GetPropertyList(type, by));
         }
+        
         #endregion
 
         [HttpGet("search")]

UnivateProperties_API/Model/Misc/Location.cs

+namespace UnivateProperties_API.Model.Misc
+{
+    public class Location : BaseEntity
+    {
+        public bool IsTesting { get; set; }
+        public string PropertyImageLocation { get; set; }
+    }
+}

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

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

UnivateProperties_API/Repository/Properties/PropertyImageRepository.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
+using UnivateProperties_API.Containers.Property;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Model.Properties;
 
                           where p.PropertyId == PropertyId
                           select p.Image).ToList();
 
-            return images;
+            List<string> formated = new List<string>();
+
+            foreach (string img in images)
+            {
+                if (!img.StartsWith("data:image"))
+                    formated.Add(ImageFormatter.ImageToBase64(img));
+                else
+                    formated.Add(img);
+            }
+
+            return formated;
         }
 
         public void Insert(PropertyImage item)

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

 using Microsoft.EntityFrameworkCore;
 using Newtonsoft.Json;
 using System;
+using System.IO;
 using System.Collections.Generic;
 using System.Linq;
 using UnivateProperties_API.Containers.Property;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Model.Logging;
 using UnivateProperties_API.Model.Properties;
+using System.Drawing;
 
 namespace UnivateProperties_API.Repository.Properties
 {
                               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}", 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();
                 }
                 Type = "Property"
             };
 
-            if (!string.IsNullOrEmpty(search.Keyword) && search.Keyword.ToUpper() != "ALL")
+            if (!string.IsNullOrEmpty(search.Keyword) && search.Keyword.ToUpper() != "ALL" && search.Keyword.ToUpper() != "UNDEFINED")
             {
                 string keyword = search.Keyword.ToLower();
 
                                          select p.UsageType.ToString()).FirstOrDefault()
                 };
 
+                if (!display.DisplayImage.StartsWith("data:image"))
+                {
+                    display.DisplayImage = ImageFormatter.ImageToBase64(display.DisplayImage);
+                }
+
                 if (!string.IsNullOrEmpty(display.Area) && display.Area.EndsWith("2"))
                 {
                     display.Area = display.Area.Substring(0, display.Area.Length - 1) + "<sup>" + display.Area.Last() + "</sup>";
             return GetDisplayDetails(props);
         }
 
-        public List<PropertyList> GetPropertyList(Func<Property, bool> where)
+        public List<PropertyList> GetPropertyList(string Type, int By)
         {
-            var properties = Get(where);
-
+            var individual = dBContext.Individuals.Where(x => x.UserId == By).FirstOrDefault();
+            var agent = dBContext.Agents.Where(x => x.UserId == By).FirstOrDefault();
+
+            List<Property> properties = new List<Property>();
+            if (Type.ToUpper() == "MY")
+            {                
+                if (individual != null)
+                    properties = Get(x => x.OwnerId == individual.Id);
+                if (agent != null)
+                    properties = Get(x => x.AgentId == agent.Id);
+            }
+            else
+            {
+                if (individual != null)
+                    properties = Get(x => x.OwnerId == individual.Id);
+                if (agent != null)
+                    properties = Get(x => x.AgencyId == agent.AgencyId);
+            }
+            
             List<PropertyList> list = new List<PropertyList>();
 
             foreach (Property p in properties)
                     prop.Size = prop.Size.Substring(0, prop.Size.Length - 1) + "<sup>" + prop.Size.Last() + "</sup>";
                 }
 
+                prop.UsageType = (dBContext.PropertyTypes.Find(p.PropertyTypeId).UsageType == PropertyUsageType.Residential ? "Residential" : "Commercial");
+                prop.SaleType = p.IsSale ? "Sale" : "Rental";
+
                 list.Add(prop);
             }
                 
         {
             // Not sure if properties need it
             return 0;
-        }
+        }       
     }
 }

UnivateProperties_API/UnivateProperties_API.csproj

     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.2.4" />
     <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.2.3" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.2.4" />
+    <PackageReference Include="System.Drawing.Common" Version="4.6.0" />
   </ItemGroup>
 
 </Project>