Property Banners - changes

UnivateProperties_API/Containers/Property/PropertyContainer.cs

         public string SalesTypeString { get; set; }
         public int UserId { get; set; }
         public string PropertyUsageType { get; set; }
+        public decimal OldPrice { get; set; }        
+        public string OldStatus { get; set; }
+        public string CutOffDisplayDateString { get; set; }
         public List<NewImage> NewImages { get; set; }
         public List<PropertyFieldGroup> PropertyOverviewFields { get; set; }
         public List<PropertyFieldGroup> PropertyFields { get; set; }

UnivateProperties_API/Containers/Property/PropertyDisplay.cs

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

UnivateProperties_API/Migrations/20200917125427_priceredused.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class priceredused : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "PriceRedused",
+                table: "Properties",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "PriceRedused",
+                table: "Properties");
+        }
+    }
+}

UnivateProperties_API/Migrations/20200918092143_Added Cutoff show date.cs

+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class AddedCutoffshowdate : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CutOffDisplayDate",
+                table: "Properties",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "CutOffDisplayDate",
+                table: "Properties");
+        }
+    }
+}

UnivateProperties_API/Migrations/DataContextModelSnapshot.cs

 
                     b.Property<DateTime>("Created");
 
+                    b.Property<DateTime>("CutOffDisplayDate");
+
                     b.Property<DateTime>("DateAvailable");
 
                     b.Property<DateTime>("DatePublished");
 
                     b.Property<string>("PricePer");
 
+                    b.Property<bool>("PriceRedused");
+
                     b.Property<string>("PropertCoords");
 
                     b.Property<string>("PropertyName");

UnivateProperties_API/Model/Properties/Property.cs

         public bool Published { get; set; }
         public DateTime DatePublished { get; set; }
         public string VirtualTour { get; set; }
+        public bool PriceRedused { get; set; }
         public string Video { get; set; }
         [ForeignKey("Status")]
-        public int? StatusId 
-        { 
-            get
-            {
-                return _StatusID;
-            }
-            set
-            {
-                _StatusID = value;
-                if (value != null)
-                {
-                    StatusDate = DateTime.Now;
-                }
-            }
-        }
+        public int? StatusId { get; set; }       
         [ForeignKey("Owner")]
         public int? OwnerId { get; set; }
         [ForeignKey("Agent")]
         public virtual PropertyType PropertyType { get; set; }            
         [NotMapped]
         public Status Status { get; set; }        
-        public virtual Individual Owner { get; set; }        
-        public virtual Agent Agent { get; set; }        
+        public virtual Individual Owner { get; set; }
+        public virtual Agent Agent { get; set; }
         public virtual Agency Agency { get; set; }
+        public DateTime CutOffDisplayDate { get; set; }        
 
         public ICollection<PropertyUserField> PropertyUserFields { get; set; }
         public ICollection<PropertyImage> PropertyImages { get; set; }

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

 
             var propertyDetails = new PropertyContainer();
 
-            propertyDetails.SalesTypeString = property.IsSale ? "Sale" : "Rental";            
+            propertyDetails.SalesTypeString = property.IsSale ? "Sale" : "Rental";
+            propertyDetails.OldPrice = property.Price;
 
             foreach (string prop in property.GetAllProperties())
             {
             }
 
             if (property.StatusId != null)
+            {
                 propertyDetails.StatusString = dBContext.Status.Where(s => s.Id == property.StatusId).FirstOrDefault()?.Description;
+                propertyDetails.OldStatus = propertyDetails.StatusString;
+            }
 
             propertyDetails.PropertyUsageType = propertyType.UsageType == PropertyUsageType.Commercial ? "Commercial" : "Residential";
 
                 propertyDetails.UserId = (dBContext.Agents.Where(p => p.Id == property.AgentId).FirstOrDefault().UserId).Value;
 
             propertyDetails.NewImages = new List<NewImage>();
-            propertyDetails.DateAvailableString = string.Format("{0:yyyy-MM-dd}", property.DateAvailable);
+
+            if (property.DateAvailable != DateTime.MinValue)
+                propertyDetails.DateAvailableString = string.Format("{0:yyyy-MM-dd}", property.DateAvailable);
+
+            if (property.CutOffDisplayDate == DateTime.MinValue)
+                propertyDetails.CutOffDisplayDateString = string.Format("{0:yyyy-MM-dd}", DateTime.Now.AddMonths(1));
+            else
+                propertyDetails.CutOffDisplayDateString = string.Format("{0:yyyy-MM-dd}", property.CutOffDisplayDate);
 
             return propertyDetails;
         }
             {
                 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))
             {
+                if (item.StatusString != item.OldStatus)
+                    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)  
+                {
+                    property.CutOffDisplayDate = DateTime.Now.AddMonths(1);
+                }
+                else
+                {
+                    property.CutOffDisplayDate = DateTime.MinValue;
+                }
+                if (item.StatusString.ToUpper() == "FOR SALE")
+                    property.IsSale = true;
+                if (item.StatusString.ToUpper() == "FOR RENT")
+                    property.IsSale = false;
             }
 
             if (!string.IsNullOrEmpty(item.DateAvailableString))
                 PropertyDisplay display = new PropertyDisplay
                 {
                     PropertyReference = item.PropertyRef,
-                    DateAvailable = item.DateAvailable,
-                    Available = item.DateAvailable.Date > DateTime.Now.Date ? string.Format("Available form: {0: dd MMM yyyy}", item.DateAvailable) : "Available Now",
+                    DateAvailable = item.DateAvailable,                    
                     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(),
-                    HasPendingOffer = false
-                };                
+                                         select p.UsageType.ToString()).FirstOrDefault()
+                };
 
-                if (item.StatusId != null)
+                var status = dBContext.Status.Where(s => s.Id == item.StatusId).FirstOrDefault();
+                switch (status.Description.ToUpper())
                 {
-                    var status = dBContext.Status.Where(s => s.Id == item.StatusId).FirstOrDefault();
-                    if (status.Description.ToUpper() == "OFFER PENDING")
-                        display.HasPendingOffer = true;                    
+                    case "FOR RENT":
+                        if (item.DateAvailable < DateTime.Now)
+                        {
+                            display.DisplayText = "Available Now";
+                            display.DisplayColor = "green";
+                        }
+                        else
+                        {
+                            display.DisplayText = string.Format("Available From: {0:dd MMM yyyy}", item.DateAvailable);
+                            display.DisplayColor = "blue";
+                        }
+                        break;
+                    case "FOR SALE":
+                        if (item.PriceRedused)
+                        {
+                            display.DisplayText = "Price Redused";
+                            display.DisplayColor = "green";
+                        }
+                        else
+                        {
+                            display.DisplayText = "For Sale";
+                            display.DisplayColor = "blue";
+                        }
+                        break;
+                    case "OFFER PENDING":
+                        display.DisplayText = "Offer Pending";
+                        display.DisplayColor = "orange";
+                        break;
+                    default:
+                        display.DisplayText = status.Description;
+                        display.DisplayColor = "red";
+                        break;
+
                 }
 
                 if (display.DisplayImage != null && !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>";
-                //}
-
-                if (display.HasPendingOffer)
-                    display.Available = "Offer Pending";
 #if !ReturnImages
                 display.DisplayImage = "";
 #endif
 
         public List<PropertyDisplay> GetLatestDisplay()
         {
-            List<Property> props = GetAll().Where(x => x.Published).OrderByDescending(x => x.DatePublished).Take(4).ToList();
+            List<Property> props = GetAll().Where(x => x.Published && (x.CutOffDisplayDate == DateTime.MinValue || x.CutOffDisplayDate.Date > DateTime.Now.Date)).OrderByDescending(x => x.DatePublished).Take(4).ToList();
             return GetDisplayDetails(props);
         }
 
                     break;
             }
 
-            List<Property> props = dBContext.Properties.Include("PropertyType").Where(x => x.Published && x.PropertyType.UsageType == type).OrderByDescending(x => x.DatePublished).Take(4).ToList();
+            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);
         }