Changes to images to store to file, return as URLs

UnivateProperties_API/Containers/Property/ImageFormatter.cs

             else
                 return "";
         }
+
+        public static string ImageToURL(string Path, string URL)
+        {
+            string url = URL;
+
+            string[] folders = Path.Split(new char[] { '\\' });
+            bool startAdd = false;
+            foreach(var folder in folders)
+            {
+                if (!startAdd && folder == "img")
+                    startAdd = true;
+
+                if (startAdd)
+                    url += folder + "/";
+            }
+
+
+            return url.Substring(0, url.Length - 1);
+        }
     }
 }

UnivateProperties_API/Context/DataContext.cs

 using Microsoft.EntityFrameworkCore;
-using Npgsql;
+using System.Data.SqlClient;
 using System.Linq;
 using UnivateProperties_API.Model;
 using UnivateProperties_API.Model.Banks;
                 {
                     connectionString = ((Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal.NpgsqlOptionsExtension)extention).ConnectionString;
                 }
+                else if (extention.GetType().ToString() == "Microsoft.EntityFrameworkCore.SqlServer.Infrastructure.Internal.SqlServerOptionsExtension")
+                {
+                    connectionString = ((Microsoft.EntityFrameworkCore.SqlServer.Infrastructure.Internal.SqlServerOptionsExtension)extention).ConnectionString;
+                }
             }
         }
 
             modelBuilder.Entity<PlaceHolderFormat>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
         }
 
-    
-        //public int GetMaxID(string tableName)
-        //{
-        //    NpgsqlConnection connection = new NpgsqlConnection(connectionString);
-        //    connection.Open();
-
-        //    NpgsqlCommand cmd = connection.CreateCommand();
-        //    cmd.CommandText = string.Format("select MAX(\"Id\") from \"{0}\"", tableName);
-        //    NpgsqlDataReader reader = cmd.ExecuteReader();
-        //    int returnValue = 0; 
-
-        //    while(reader.Read())
-        //    {
-        //        returnValue = int.Parse(reader[0] == null ? "0" : reader[0].ToString() == "" ? "0" : reader[0].ToString());
-        //    }
-
-        //    connection.Close();
-        //    return returnValue;
-        //}
+
+        public int GetMaxID(string tableName)
+        {
+            SqlConnection connection = new SqlConnection(connectionString);
+            connection.Open();
+
+            SqlCommand cmd = connection.CreateCommand();
+            cmd.CommandText = string.Format("select MAX(\"Id\") from \"{0}\"", tableName);
+            SqlDataReader reader = cmd.ExecuteReader();
+            int returnValue = 0;
+
+            while (reader.Read())
+            {
+                returnValue = int.Parse(reader[0] == null ? "0" : reader[0].ToString() == "" ? "0" : reader[0].ToString());
+            }
+
+            connection.Close();
+            return returnValue;
+        }
     }
 }

UnivateProperties_API/Controllers/Properties/PropertyImageController.cs

             return new OkObjectResult(_Repo.Get(x => x.PropertyId == PropertyId));
         }
 
+        [HttpGet("SavePropImages")]
+        public IActionResult SavePropImages()
+        {
+            _Repo.UpdateToPhysical();
+            return new OkResult();
+        }
+
         [HttpPost]
         public IActionResult Post([FromBody] NewPropertyImages propertyImage)
         {

UnivateProperties_API/Migrations/20201110092829_URL added to location.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class URLaddedtolocation : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "SiteURL",
+                table: "Location",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "SiteURL",
+                table: "Location");
+        }
+    }
+}

UnivateProperties_API/Migrations/DataContextModelSnapshot.cs

 
                     b.Property<string>("PropertyImageLocation");
 
+                    b.Property<string>("SiteURL");
+
                     b.HasKey("Id");
 
                     b.ToTable("Location");

UnivateProperties_API/Model/Misc/Location.cs

     {
         public bool IsTesting { get; set; }
         public string PropertyImageLocation { get; set; }
+        public string SiteURL { get; set; }
     }
 }

UnivateProperties_API/Repository/Properties/IPropertyImageRepository.cs

     {
         List<string> GetImages(int PropertyId);
         void Update(NewPropertyImages propertyImages);
+        void UpdateToPhysical();
     }
 }

UnivateProperties_API/Repository/Properties/PropertyImageRepository.cs

         {
             var images = dBContext.PropertyImages.Where(where).OrderByDescending(i => i.IsDefault).ThenBy(i => i.Id).ToList();
 
+            var url = dBContext.Location.FirstOrDefault()?.SiteURL;
+
             foreach (PropertyImage img in images)
             {
                 if (!img.Image.StartsWith("data:image"))
-                    img.Image = ImageFormatter.ImageToBase64(img.Image);                
+                {
+                    if (!string.IsNullOrEmpty(url))
+                        img.Image = ImageFormatter.ImageToURL(img.Image, url);
+                    else
+                        img.Image = ImageFormatter.ImageToBase64(img.Image);
+                }
             }
 
             return images;
 
             List<string> formated = new List<string>();
 
+            var url = dBContext.Location.FirstOrDefault()?.SiteURL;
+
             foreach (string img in images)
             {
                 if (!img.StartsWith("data:image"))
-                    formated.Add(ImageFormatter.ImageToBase64(img));
+                {
+                    if (!string.IsNullOrEmpty(url))
+                        formated.Add(ImageFormatter.ImageToURL(img, url));
+                    else
+                        formated.Add(ImageFormatter.ImageToBase64(img));
+                }
                 else
                     formated.Add(img);
             }
                 if (!string.IsNullOrEmpty(loc))
                 {
                     saveFiles = true;
+                    if (loc.EndsWith("\\"))
+                    {
+                        loc = loc.Substring(0, loc.Length - 1);
+                    }
                     loc += string.Format("\\{0}", propertyImages.PropertyId);
-                    if (Directory.Exists(loc))
+                    if (!Directory.Exists(loc))
                     {
                         Directory.CreateDirectory(loc);
                     }
                 Save();
             }
         }
+
+        public void UpdateToPhysical()
+        {            
+            bool saveFiles = false;
+            var loc = dBContext.Location.FirstOrDefault()?.PropertyImageLocation;
+            if (!string.IsNullOrEmpty(loc))
+            {
+                saveFiles = true;
+                if (loc.EndsWith("\\"))
+                {
+                    loc = loc.Substring(0, loc.Length - 1);
+                }
+            }
+
+            if (saveFiles)
+            {
+                var images = dBContext.PropertyImages.ToList();
+                foreach (var image in images)
+                {
+                    string filePath = string.Format("{0}\\{1}", loc, image.PropertyId );
+                    if (!Directory.Exists(filePath))
+                    {
+                        Directory.CreateDirectory(filePath);
+                    }
+
+                    string path = ImageFormatter.Base64ToImage(image.Image, filePath, image.Id.ToString());
+                    image.Image = path;
+                }
+
+                Save();
+            }
+        }
     }
 }

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

         public List<Property> Get(Func<Property, bool> where)
         {
             return dBContext.Properties
-                .Include("PropertyType")                
+                .Include("PropertyType")
                 .Where(where).ToList();
         }
 
 
         public Property GetDetailed(Func<Property, bool> first)
         {
-            throw new NotImplementedException();            
+            throw new NotImplementedException();
         }
 
         public PropertyContainer GetDetailed(int id, bool detailed)
         }
 
         private PropertyContainer GetDetail(Property property, bool detailed)
-        {            
+        {
             int propID = property.Id;
-            var propertyType = dBContext.PropertyTypes.Find(property.PropertyTypeId);           
-            property.DisplayData = new List<PropertyDetailGroup>();            
+            var propertyType = dBContext.PropertyTypes.Find(property.PropertyTypeId);
+            property.DisplayData = new List<PropertyDetailGroup>();
 
             if (detailed)
             {
             {
                 if (prop != "Item" && prop != "Display")
                     property[prop] = item[prop];
-            }            
+            }
 
             property.PropertyUserFields = null;
             property.PropertyImages = null;
             if (item.Price < item.OldPrice)
             {
                 property.PriceRedused = true;
-            }            
+            }
 
             if (!string.IsNullOrEmpty(item.StatusString))
             {
                     property.StatusDate = DateTime.Now;
 
                 property.StatusId = dBContext.Status.Where(s => s.Description == item.StatusString && s.StatusType == StatusType.Property).FirstOrDefault()?.Id;
-                if ((item.StatusString.ToUpper() == "RENTED OUT" || item.StatusString.ToUpper() == "SOLD") && item.StatusString != item.OldStatus)  
+                if ((item.StatusString.ToUpper() == "RENTED OUT" || item.StatusString.ToUpper() == "SOLD") && item.StatusString != item.OldStatus)
                 {
                     property.CutOffDisplayDate = DateTime.Now.AddMonths(1);
                 }
                             dBContext.Entry(propField).State = EntityState.Modified;
                             Save();
                         }
-                    }                    
+                    }
                 }
             }
             #endregion
             }
 
             if (item.NewImages != null)
-            {                
+            {
                 bool saveFiles = false;
                 var loc = dBContext.Location.FirstOrDefault()?.PropertyImageLocation;
                 if (!string.IsNullOrEmpty(loc))
                 {
                     saveFiles = true;
+                    if (loc.EndsWith("\\"))
+                    {
+                        loc = loc.Substring(0, loc.Length - 1);
+                    }
                     loc += string.Format("\\{0}", property.Id);
-                    if (Directory.Exists(loc))
+                    if (!Directory.Exists(loc))
                     {
                         Directory.CreateDirectory(loc);
                     }
                 }
 
-                             
+
                 var lastID = dBContext.PropertyImages.Max(i => i.Id) + 1;
                 foreach (var image in item.NewImages)
                 {
+                    if (!image.Image.StartsWith("data:image")) 
+                        continue;
+
                     var propImage = new PropertyImage
                     {
                         PropertyId = property.Id,
                         dBContext.PropertyImages.Add(propImage);
                         Save();
                         lastID++;
-                    }                                        
+                    }
                 }
             }
 
 
             return GetDisplayDetails(props);
         }
-        
+
         public List<PropertyDisplay> GetDisplay(PropertySearch search)
         {
             //return GetDisplayDetails(dBContext.Properties.ToList());
             {
                 string keyword = search.Keyword.ToLower();
 
-                List<Property> props = (from p in dBContext.Properties                                       
+                List<Property> props = (from p in dBContext.Properties
                                         join pt in dBContext.PropertyTypes on p.PropertyTypeId equals pt.Id
                                         where EF.Functions.Like(p.PropertyName.ToLower(), $"%{keyword}%")
                                         || EF.Functions.Like(p.Province.ToLower(), $"%{keyword}%")
 
                 if (!string.IsNullOrEmpty(search.Province) && search.Province != "undefined" && search.Province.ToUpper() != "ALL")
                 {
-                    props = (from p in props                            
+                    props = (from p in props
                              where p.Province.ToUpper() == search.Province.ToUpper()
                              select p).ToList();
 
 
                 if (!string.IsNullOrEmpty(search.City) && search.City != "undefined" && search.City.ToUpper() != "ALL")
                 {
-                    props = (from p in props                             
+                    props = (from p in props
                              where p.City.ToUpper() == search.City.ToUpper()
                              select p).ToList();
 
 
                 if (!string.IsNullOrEmpty(search.Suburb) && search.Suburb != "undefined" && search.Suburb.ToUpper() != "ALL")
                 {
-                    props = (from p in props                             
+                    props = (from p in props
                              where p.Suburb.ToUpper() == search.Suburb.ToUpper()
                              select p).ToList();
 
 
                 return GetDisplayDetails(props);
             }
-        }        
+        }
 
         private void SaveLog(SearchObject item)
         {
             {
                 Type = item.Type,
                 Search = JsonConvert.SerializeObject(item)
-            };            
+            };
             dBContext.SearchLogs.Add(searchLog);
             Save();
         }
                 PropertyDisplay display = new PropertyDisplay
                 {
                     PropertyReference = item.PropertyRef,
-                    DateAvailable = item.DateAvailable,                    
+                    DateAvailable = item.DateAvailable,
                     Id = item.Id,
                     ShortDescription = item.ShortDescription,
                     IsSale = item.IsSale,
                     break;
             }
 
-            List<Property> props = dBContext.Properties.Include("PropertyType").Where(x => x.Published 
-                        && x.PropertyType.UsageType == type 
+            List<Property> props = dBContext.Properties.Include("PropertyType").Where(x => x.Published
+                        && x.PropertyType.UsageType == type
                         && (x.CutOffDisplayDate == DateTime.MinValue || x.CutOffDisplayDate.Date > DateTime.Now.Date)).OrderByDescending(x => x.DatePublished).Take(4).ToList();
             return GetDisplayDetails(props);
         }
         }
 
         public List<PropertyList> GetPropertyList()
-        {           
+        {
             return SetPropertyList(dBContext.Properties.Where(x => x.Published).ToList());
         }
 
 
         public void Insert(PropertyContainer items)
         {
-            Property property = new Property();            
+            Property property = new Property();
             PropertyType pt = dBContext.PropertyTypes.Find(items.PropertyTypeId);
             if (pt != 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();            
+            var agent = dBContext.Agents.Where(a => a.UserId == items.UserId).FirstOrDefault();
 
-            foreach( string prop in property.GetAllProperties())
+            foreach (string prop in property.GetAllProperties())
             {
                 if (prop != "Item" && prop != "Display")
                     property[prop] = items[prop];
             {
                 property.AgencyId = agent.AgencyId;
                 property.AgentId = agent.Id;
-            }            
+            }
 
-            if (property.IsSale)            
+            if (property.IsSale)
                 property.StatusId = dBContext.Status.Where(s => s.Description == "For Sale" && s.StatusType == StatusType.Property).FirstOrDefault()?.Id;
             else
                 property.StatusId = dBContext.Status.Where(s => s.Description == "For Rent" && s.StatusType == StatusType.Property).FirstOrDefault()?.Id;
             if (images != null)
             {
                 bool saveFiles = false;
+                var nextPropID = dBContext.GetMaxID("Properties") + 1;
                 var loc = dBContext.Location.FirstOrDefault()?.PropertyImageLocation;
                 if (!string.IsNullOrEmpty(loc))
                 {
                     saveFiles = true;
-                    loc += string.Format("\\{0}", property.Id);
-                    if (Directory.Exists(loc))
+                    if (loc.EndsWith("\\"))
+                    {
+                        loc = loc.Substring(0, loc.Length - 1);
+                    }
+                    loc += string.Format("\\{0}", nextPropID);
+                    if (!Directory.Exists(loc))
                     {
                         Directory.CreateDirectory(loc);
                     }
                 var lastID = 0;
                 if (dBContext.PropertyImages.Count() == 0)
                     lastID = 1;
-                else 
+                else
                     lastID = dBContext.PropertyImages.Max(i => i.Id) + 1;
 
                 foreach (PropertyImage image in images)
             }
 
             if (fields != null)
-            {                
+            {
                 property.PropertyUserFields = new List<PropertyUserField>();
                 foreach (PropertyUserField field in fields)
                 {
             dBContext.Properties.Add(property);
             Save();
 
-            items.Id = property.Id;            
+            items.Id = property.Id;
         }
 
         public bool MayEdit(int id)
                 }
 
                 foreach (PropertyImage image in Images)
-                {                                    
+                {
                     image.PropertyId = propertyID;
                     if (saveFiles)
                     {
                     IsPublished = prop.Published,
                     Type = prop.PropertyType.UsageType.ToString()
                 };
-                
+
                 if (prop.StatusId != null)
                 {
                     propAdmin.Status = dBContext.Status.Where(s => s.Id == prop.StatusId).FirstOrDefault()?.Description;