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

UnivateProperties_API/Containers/Property/PropertyDisplay.cs

         public string DisplayImage { get; set; }
         public decimal Price { get; set; }        
         public DateTime DateCreated { get; set; }
-        #endregion 
+        public DateTime DateAvailable { get; set; }
+        public string Available { get; set; }
+        public bool HasPendingOffer { get; set; }
+        #endregion
     }
 }

UnivateProperties_API/Containers/Property/PropertyList.cs

-namespace UnivateProperties_API.Containers.Property
+using System;
+
+namespace UnivateProperties_API.Containers.Property
 {
     public class PropertyList
     {
         #region Properties
         public string Name { get; set; }
         public int Id { get; set; }
+        public DateTime DateAvailable { get; set; }
         public string Size { get; set; }
         public string Price { get; set; }
         public string UsageType { get; set;  }

UnivateProperties_API/Containers/Property/PropertySearch.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace UnivateProperties_API.Containers.Property
 {
         public string Suburb { get; set; }
         public decimal MinPrice { get; set; }
         public decimal MaxPrice { get; set; }
-        #endregion 
+        public DateTime AvailableFrom { get; set; }
+        public int PropertyId { get; set; }
+        #endregion
     }
 }

UnivateProperties_API/Containers/Timeshare/Detailed/DetailedAddress.cs

 
         }
 
-        public DetailedAddress(int id, string streetNumber, string street, string suburb, string city, string postalCode)
+        public DetailedAddress(int id, string streetNumber, string street, string suburb, string city, string postalCode, string province)
         {
             Id = id;
             StreetNumber = streetNumber;
             Street = street;
             Suburb = suburb;
             City = city;
+            Province = province;
             PostalCode = postalCode;
         }
 
             Street = address.Street;
             Suburb = address.Suburb;
             City = address.City;
+            Province = address.Province;
             PostalCode = address.PostalCode;
         }
 
         public string Street { get; set; } = "";
         public string Suburb { get; set; } = "";
         public string City { get; set; } = "";
+        public string Province { get; set; } = "";
         public string PostalCode { get; set; } = "";
     }
 }

UnivateProperties_API/Controllers/Properties/PropertyController.cs

 using Microsoft.AspNetCore.Mvc;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Transactions;
         }
 
         //Will need to come out. Post search not working......:(
-        [HttpGet("search/{userName}/{keyword}/{salesType}/{propertyUsageType}/{propertyType}/{province}/{city}/{suburb}/{minPrice}/{maxPrice}")]
-        public IActionResult Search(string userName, string keyword, string salesType, string propertyUsageType, string propertyType, string province, string city, string suburb, decimal minPrice, decimal maxPrice)
+        [HttpGet("search/{userName}/{keyword}/{salesType}/{propertyUsageType}/{propertyType}/{province}/{city}/{suburb}/{minPrice}/{maxPrice}/{availableFrom}/{propertyId}")]
+        public IActionResult Search(string userName, string keyword, string salesType, string propertyUsageType, string propertyType, string province, string city, string suburb, decimal minPrice, decimal maxPrice, string availableFrom, int propertyId)
         {
             var search = new PropertySearch()
             {
                 City = city,
                 Suburb = suburb,
                 MinPrice = minPrice,
-                MaxPrice = maxPrice
-            };
+                MaxPrice = maxPrice,
+                PropertyId = propertyId
+            };            
+
+            if (availableFrom == "undefined")
+                search.AvailableFrom = DateTime.MinValue;
+            else
+                search.AvailableFrom = DateTime.Parse(availableFrom);
 
             return new OkObjectResult(_Repo.GetDisplay(search));
         }

UnivateProperties_API/Controllers/Users/IndividualController.cs

 using System.Transactions;
 using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Containers.Timeshare.Detailed;
 using UnivateProperties_API.Model.Users;
 using UnivateProperties_API.Repository;
 using UnivateProperties_API.Repository.Users;
         //Gets data from DB by Id
         [HttpGet("{id}")]
         public IActionResult Get(int id)
-        {
+        {            
             return new OkObjectResult(_Repo.Get(x => x.Id == id));
         }
 
             return new OkObjectResult((_Repo as IndividualRepository).GetAllIndividuals());
         }
 
-        //Updates to DB
         [HttpPut()]
-        public IActionResult Put([FromBody] Individual individual)
+        public IActionResult Put([FromBody]DetailedOwner owner)
         {
-            if (individual != null)
+            if (owner != null)
             {
                 using (var scope = new TransactionScope())
                 {
-                    _Repo.Update(individual);
+                    (_Repo as IndividualRepository).Update(owner);
                     scope.Complete();
                     return new OkResult();
                 }

UnivateProperties_API/Helpers/MyCommon.cs

 
             return true;
         }
+
+        public static string CreateRandomPassword(int length = 6)
+        {
+            string validChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*?_-";
+            Random random = new Random();
+
+            char[] chars = new char[length];
+            for (int i = 0; i < length; i++)
+            {
+                chars[i] = validChars[random.Next(0, validChars.Length)];
+            }
+            return new string(chars);
+        }
     }
 }

UnivateProperties_API/Model/Misc/Address.cs

         public string Suburb { get; set; }
         public string City { get; set; }
         public string PostalCode { get; set; }
+        public string Province { get; set; }
         [ForeignKey("Owner")]
         public int? OwnerId { get; set; }
 

UnivateProperties_API/Model/Properties/Property.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations.Schema;
 using UnivateProperties_API.Containers.Property;
 using UnivateProperties_API.Model.ProcessFlow;
 namespace UnivateProperties_API.Model.Properties
 {
     public class Property : BaseEntity
-    {        
+    {
         #region Properties        
-        [ForeignKey("PropertyType")]        
+        [ForeignKey("PropertyType")]
         public int PropertyTypeId { get; set; }
         public string PropertyName { get; set; }
         public string Unit { get; set; }
-        public decimal OperationalCosts { get; set; }           
+        public decimal OperationalCosts { get; set; }
         public decimal Price { get; set; }
         public string PricePer { get; set; }
         public bool IsSale { get; set; }
         [ForeignKey("Agent")]
         public int? AgentId { get; set; }
         [ForeignKey("Agency")]
-        public int? AgencyId { get; set; }        
+        public int? AgencyId { get; set; }
+        public DateTime DateAvailable { get; set; }
 
         public virtual PropertyType PropertyType { get; set; }
         public virtual Province Province { get; set; }

UnivateProperties_API/Model/Users/Individual.cs

 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
+using UnivateProperties_API.Containers.Timeshare.Detailed;
 using UnivateProperties_API.Model.Banks;
 using UnivateProperties_API.Model.Misc;
 using UnivateProperties_API.Model.Properties;
         {
 
         }
+
         #endregion Constructor
 
         #region Properties
         public virtual BankAccount BankAccount { get; set; }
         public virtual ICollection<Property> Properties { get; set; }
         #endregion Properties
+
+        #region Methods
+        public void UpdateFromDetailedOwner(DetailedOwner owner)
+        {
+            if (owner.Id == Id)
+            {
+                Name = owner.Name;
+                Surname = owner.Surname;
+                IdNumber = owner.IdNumber;
+                CompanyRegNumber = owner.CompanyRegNumber;
+                MaritalStatus = owner.MaritalStatus;
+                Email = owner.EmailAddress;
+                CellNumber = owner.CellNumber;
+                Telephone = owner.LandlineNumber;
+
+                if (owner.Address != null)
+                {
+                    if (Address == null)
+                    {
+                        Address = new Address()
+                        {
+                            StreetNumber = owner.Address.StreetNumber,
+                            Street = owner.Address.Street,
+                            City = owner.Address.City,
+                            Suburb = owner.Address.Suburb,
+                            Province = owner.Address.Province,
+                            PostalCode = owner.Address.PostalCode
+                        };
+                    }
+                    else
+                    {
+                        Address.StreetNumber = owner.Address.StreetNumber;
+                        Address.Street = owner.Address.Street;
+                        Address.City = owner.Address.City;
+                        Address.Suburb = owner.Address.Suburb;
+                        Address.Province = owner.Address.Province;
+                        Address.PostalCode = owner.Address.PostalCode;
+                    }
+
+                }
+
+                if (owner.BankingDetails != null)
+                {
+                    if (BankAccount == null)
+                    {
+                        BankAccount = new BankAccount()
+                        {
+                            BankId = owner.BankingDetails.BankId,
+                            AccountNumber = owner.BankingDetails.AccountNumber,
+                            AccountHolder = owner.BankingDetails.AccountHolder
+                        };
+                    }
+                    else
+                    {
+                        BankAccount.BankId = owner.BankingDetails.BankId;
+                        BankAccount.AccountNumber = owner.BankingDetails.AccountNumber;
+                        BankAccount.AccountHolder = owner.BankingDetails.AccountHolder;
+                    }
+                }
+            }
+        }
+        #endregion Methods
     }
 }

UnivateProperties_API/Repository/Properties/PropertyImageRepository.cs

         }
         public List<PropertyImage> Get(Func<PropertyImage, bool> where)
         {
-            var images = dBContext.PropertyImages.Where(where).ToList();
+            var images = dBContext.PropertyImages.Where(where).OrderByDescending(i => i.IsDefault).ThenBy(i => i.Id).ToList();
 
             foreach (PropertyImage img in images)
             {
         {
             var images = (from p in dBContext.PropertyImages
                           where p.PropertyId == PropertyId
-                          select p.Image).ToList();
+                          orderby p.IsDefault descending
+                          select p.Image).ToList();            
 
             List<string> formated = new List<string>();
 

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

-using Microsoft.EntityFrameworkCore;
+#define ReturnImages
+//#undef ReturnImages  //Comment out to return images
+
+using Microsoft.EntityFrameworkCore;
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 
                         foreach (var val in groupFields)
                         {
-                            var irem = new PropertyDetail()
+                            var item = new PropertyDetail()
                             {
                                 Name = val.FieldName,
                                 Description = val.Description
                             };
 
-                            detailGroup.Values.Add(irem);
+                            detailGroup.Values.Add(item);
 
-                            if ((val.FieldName == "Erf Size" || val.FieldName == "Floor Size") && val.Value.EndsWith("2"))
+                            if (!string.IsNullOrEmpty(val.Value) && (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>";
+                                item.Value = val.Value.Substring(0, val.Value.Length - 1) + "<sup>" + val.Value.Last() + "</sup>";
                             }
                             else
-                                irem.Value = val.Value;
+                                item.Value = val.Value;
                         }
 
                         property.DisplayData.Add(detailGroup);
         
         public List<PropertyDisplay> GetDisplay(PropertySearch search)
         {
+            //return GetDisplayDetails(dBContext.Properties.ToList());
+
+            //StreamWriter SW = new StreamWriter(@"c:\temp\SearchData.txt", true);
+            //SW.WriteLine(string.Format("{0:yyyy-MM-dd hh:mm:ss} - {1}", DateTime.Now, JsonConvert.SerializeObject(search)));
+            //SW.Close();
+
             SearchObject obj = new SearchObject()
             {
                 UserName = search.UserName,
             else
             {
                 List<Property> props;
+
+                //Property ID search will override other searches. 
+                if (search.PropertyId > 0)
+                {
+                    props = dBContext.Properties.Where(p => p.Id == search.PropertyId).ToList();
+                    return GetDisplayDetails(props);
+                }
+
                 PropertyUsageType uType = PropertyUsageType.Both;
 
                 if (!string.IsNullOrEmpty(search.PropertyUsageType) && search.PropertyUsageType != "undefined" && search.PropertyUsageType.ToUpper() != "ALL")
                 if (!string.IsNullOrEmpty(search.SalesType) && search.SalesType != "undefined" && search.SalesType.ToUpper() != "ALL")
                 {
                     if (search.SalesType.ToUpper() == "SALE")
+                    {
                         props = props.Where(p => p.IsSale).ToList();
+                        search.AvailableFrom = DateTime.MinValue; //Sales do not have an available from date. 
+                    }
                     else
                         props = props.Where(p => !p.IsSale).ToList();
 
                     SaveLog(obj);
                 }
 
+                if (search.AvailableFrom != DateTime.MinValue)
+                {
+                    props = props.Where(p => p.DateAvailable.Date >= search.AvailableFrom.Date).ToList();
+
+                    obj.Property = "AvailableFrom";
+                    obj.Value = search.AvailableFrom.ToString();
+                    SaveLog(obj);
+                }
+
                 return GetDisplayDetails(props);
             }
         }        
         {
             var properties = new List<PropertyDisplay>();
             foreach (var item in props)
-            {
+            {                
                 PropertyDisplay display = new PropertyDisplay
-                {
+                {          
+                    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,
                     ShortDescription = item.ShortDescription,
                     IsSale = item.IsSale,
                     DateCreated = item.Created,
                     PropertyUsageType = (from p in dBContext.PropertyTypes
                                          where p.Id == item.PropertyTypeId
-                                         select p.UsageType.ToString()).FirstOrDefault()
+                                         select p.UsageType.ToString()).FirstOrDefault(),
+                    HasPendingOffer = !MayEdit(item.Id)
                 };
 
                 if (display.DisplayImage != null && !display.DisplayImage.StartsWith("data:image"))
                     display.Area = display.Area.Substring(0, display.Area.Length - 1) + "<sup>" + display.Area.Last() + "</sup>";
                 }
 
+                if (display.HasPendingOffer)
+                    display.Available = "Offer Pending";
+#if !ReturnImages
+                display.DisplayImage = "";
+#endif
                 properties.Add(display);
             }
 
                     Price = string.Format("R {0:n}", p.Price),
                     Publish = p.Published.ToString(),
                     Type = dBContext.PropertyTypes.Find(p.PropertyTypeId)?.Description,
-                    CarouselDescription = string.Format("{0}, {1} <br/>{2}", p.Suburb.Description, p.City.Description, p.AddressLine3)
+                    CarouselDescription = string.Format("{0}, {1} <br/>{2}", p.Suburb.Description, p.City.Description, p.AddressLine3),
+                    DateAvailable = p.DateAvailable
                 };
 
                 prop.Size = (from u in dBContext.PropertyUserFields

UnivateProperties_API/Repository/Users/AgentRepository.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
+using UnivateProperties_API.Containers.Users;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Model.Users;
 
         public void Insert(Agent item)
         {
             item.Id = NewId();
+            item.User.Role = Role.Agent;
+            if (_dbContext.Agents.Any(a => a.AgencyId == null))
+            {
+                item.AgencyId = 10;
+            }
             _dbContext.Add(item);
             Save();
         }

UnivateProperties_API/Repository/Users/IndividualRepository.cs

 
         public List<Individual> GetAll()
         {
-            foreach(var item in _dbContext.Individuals.Include("User").ToList())
+            foreach(var item in _dbContext.Individuals.Include("User").Include("Address").Include("BankAccount").ToList())
             {
                 var list = MyCommon.GetVisibleColumns(item);
             }
 
         public DetailedOwner GetIndividual(int id)
         {
-            var item = _dbContext.Individuals.FirstOrDefault(x => x.UserId == id);
+            var item = _dbContext.Individuals.Include("Address").Include("BankAccount").FirstOrDefault(x => x.UserId == id);
             if(item != null)
             {
                 return new DetailedOwner(item);
             Save();
         }
 
+        public void Update(DetailedOwner item)
+        {
+            var individual = _dbContext.Individuals.Include("Address").Include("BankAccount").FirstOrDefault(x => x.Id == item.Id);
+            if (individual != null)
+            {
+                individual.UpdateFromDetailedOwner(item);
+            }
+            _dbContext.Entry(individual).State = EntityState.Modified;
+            Save();
+        }
+
         public void Save()
         {
             _dbContext.SaveChanges();
             id += 1;
             return id;
         }
+
+        //public List<Individual> PasswordReset(Individual item)
+        //{
+        //    var individual = _dbContext.Individuals.Include("User").FirstOrDefault(x => x.Id == item.Id);
+        //    if (individual != null)
+        //    {
+        //        individual.User.PasswordHash = MyCommon.CreateRandomPassword(item);
+        //    }
+        //    return item;
+        //}
     }
 }

UnivateProperties_API/Repository/Users/RegisterRepository.cs

 using UnivateProperties_API.Containers.Users.Simple;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Helpers;
+using UnivateProperties_API.Model.Communication;
 using UnivateProperties_API.Model.Users;
+using UnivateProperties_API.Repository.Communication;
 
 namespace UnivateProperties_API.Repository.Users
 {
 
             Create(createUser, individual.Password, false);
 
+            Person p = null;
+            
             if (personType == PersonType.Agent)
             {
                 Agent agent = new Agent()
                     Agency = agency
                 };
                 agent.Id = NewAgentId();
+                agent.User.Role = Role.Agency;
+                p = agent;
                 _dbContext.Agents.Add(agent);
             }
             else if (personType == PersonType.Individual)
                     Telephone = individual.Telephone
                 };
                 i.Id = NewIndividualId();
+                i.User.Role = Role.PrivateUser;
+                p = i;
                 _dbContext.Individuals.Add(i);
+
+            }
+            Template template = _dbContext.Templates.FirstOrDefault(x => x.Name == "IndivRegEmail");
+            if (template != null && personType == PersonType.Individual)
+            {
+                    TemplateRepository templateRepository = new TemplateRepository(_dbContext);
+                    templateRepository.SendEmailTemplate(template, p, new List<Model.BaseEntity>() { p });
+            }
+
+            Template templ = _dbContext.Templates.FirstOrDefault(x => x.Name == "AgencyRegEmail");
+            if (templ != null)
+            {
+                TemplateRepository templateRepository = new TemplateRepository(_dbContext);
+                templateRepository.SendEmailTemplate(templ, p, new List<Model.BaseEntity>() { p });
             }
+
+            Template temp = _dbContext.Templates.FirstOrDefault(x => x.Name == "VerificationEmail");
+            if (temp != null)
+            {
+                TemplateRepository templateRepository = new TemplateRepository(_dbContext);
+                templateRepository.SendEmailTemplate(temp, p, new List<Model.BaseEntity>() { p });
+            }
+
             if (save)
             {
                 Save();