Merge branch 'master' of http://provision-sa.co.za:3000/Provision/UnivatePropertiesAPI

UnivateProperties_API/Containers/Property/PropertyContainer.cs

 namespace UnivateProperties_API.Containers.Property
 {
     public class PropertyContainer : Model.Properties.Property
-    {
+    {        
+        public string StatusString { get; set; }
+        public string SalesTypeString { get; set; }
         public int UserId { get; set; }
         public string PropertyUsageType { get; set; }
         public List<NewImage> NewImages { get; set; }
         public int PropertyId { get; set; }
         public List<PropertyImage> Images { get; set; }
     }
+
+    public class PropertyAdminContainer
+    {
+        public int Id { get; set; }
+        public string Owner { get; set; }
+        public string Property { get; set; }
+        public string Reference { get; set; }
+        public string Unit { get; set; }
+        public string Size { get; set; }
+        public decimal Price { get; set; }
+        public string Region { get; set; }
+        public string Town { get; set; }
+        public string Suburb { get; set; }
+        public string Status { get; set; }
+        public string Type { get; set; }
+        public bool IsPublished { get; set; }
+    }
 }

UnivateProperties_API/Context/DataContext.cs

 
         #region Payments
         public DbSet<Payment> Payments { get; set; }
+        public DbSet<ListingFee> ListingFees { get; set; }
         #endregion
 
         #region Campaign

UnivateProperties_API/Controllers/Financial/FeesController.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Financial;
+using UnivateProperties_API.Repository.Financial;
+
+namespace UnivateProperties_API.Controllers.Financial
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class FeesController : ControllerBase
+    {
+        private readonly IListingRepository _repo;
+
+        public FeesController(IListingRepository rp)
+        {
+            _repo = rp;
+        }
+
+        // GET: api/Fees/listingFee
+        [HttpGet("listingFee")]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_repo.GetListingFee());
+        }
+
+        // POST: api/Fees
+        [HttpPost("listingFee")]
+        public IActionResult Post([FromBody] ListingFee fee)
+        {
+            var feeObj = _repo.insertListingFee(fee);
+            if (feeObj != null)
+            {
+                return new OkObjectResult(fee);
+            }
+            else
+            {
+                return new NoContentResult();
+            }
+        }
+
+        // PUT: api/Fees/5
+        [HttpPut("{id}")]
+        public void Put(int id, [FromBody] string value)
+        {
+        }
+
+        // DELETE: api/ApiWithActions/5
+        [HttpDelete("{id}")]
+        public void Delete(int id)
+        {
+        }
+    }
+}

UnivateProperties_API/Controllers/Properties/PropertyController.cs

             return new OkObjectResult(_Repo.MayEdit(id));
         }
 
+        [HttpGet("GetAdminProperties/{userId}")]
+        public IActionResult GetAdminProperties(int userId)
+        {
+            return new OkObjectResult(_Repo.GetAdminProperties(userId));
+        }
+
+        [HttpGet("GetPropertyStatuses")]
+        public IActionResult GetPropertyStatuses()
+        {
+            return new OkObjectResult(_Repo.GetStatuses());
+        }
         #endregion
 
         [HttpGet("search")]
         }
         
         [HttpPut("PublishProperty")]
-        public IActionResult PublishProperty([FromBody] PropertyDisplay property)
+        public IActionResult PublishProperty([FromBody] PropertyAdminContainer property)
         {
             _Repo.PublishProperty(property.Id);
             return new NoContentResult();
         }
 
         [HttpPut("UnpublishProperty")]
-        public IActionResult UnpublishProperty(PropertyDisplay property)
+        public IActionResult UnpublishProperty(PropertyAdminContainer property)
         {
             _Repo.UnpublishProperty(property.Id);
             return new NoContentResult();

UnivateProperties_API/Controllers/Properties/PropertyFieldsController.cs

         {
             return new OkObjectResult(_Repo.GetFieldList(propertyType, name, id));
         }
+
+        [HttpGet("GetSavedPropertyUserFields/{id}")]
+        public IActionResult GetSavedPropertyUserFields(int id)
+        {
+            return new OkObjectResult(_Repo.GetSavedList(id));
+        }
     }
 
 

UnivateProperties_API/Migrations/20200910134303_ListingFees.cs

+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class ListingFees : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "ListingFees",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
+                    Amount = table.Column<double>(nullable: false),
+                    Name = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ListingFees", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ListingFees");
+        }
+    }
+}

UnivateProperties_API/Migrations/20200910135810_ListingFees1.cs

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

UnivateProperties_API/Migrations/20200910140429_ListingFees2.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class ListingFees2 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

UnivateProperties_API/Migrations/20200910140623_ListingFees3.cs

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

UnivateProperties_API/Migrations/DataContextModelSnapshot.cs

                     b.ToTable("Templates");
                 });
 
+            modelBuilder.Entity("UnivateProperties_API.Model.Financial.ListingFee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<double>("Amount");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ListingFees");
+                });
+
             modelBuilder.Entity("UnivateProperties_API.Model.Financial.Payment", b =>
                 {
                     b.Property<int>("Id")

UnivateProperties_API/Model/Financial/ListingFee.cs

+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace UnivateProperties_API.Model.Financial
+{
+    public class ListingFee : BaseEntity
+    {
+        public double Amount {get; set;}
+        public string Name { get; set; }
+    }
+}

UnivateProperties_API/Repository/Financial/ListingRepository.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Financial;
+
+namespace UnivateProperties_API.Repository.Financial
+{
+    public interface IListingRepository
+    {
+        ListingFee insertListingFee(ListingFee fee);
+        ListingFee GetListingFee();
+    }
+
+    public class ListingRepository : IListingRepository
+    {
+        private readonly DataContext _dbContext;
+
+        public ListingRepository(DataContext db)
+        {
+            _dbContext = db;
+        }
+
+        public ListingFee insertListingFee(ListingFee fee)
+        {
+            var hasFee = _dbContext.ListingFees.FirstOrDefault();
+            if (fee != null)
+            {
+                if (hasFee == null)
+                {
+                    _dbContext.ListingFees.Add(fee);
+                    _dbContext.SaveChanges();
+                    return fee;
+                }
+                else
+                {
+                    fee.Id = 1;
+                    _dbContext.ListingFees.Update(fee);
+                    _dbContext.SaveChanges();
+                    return fee;
+                }
+                
+            }
+            else
+            {
+                return null;
+            }
+            
+        }
+
+        public ListingFee GetListingFee()
+        {
+            return _dbContext.ListingFees.FirstOrDefault();
+        }
+    }
+}

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

         List<PropertyType> GetPropertyTypes(Func<PropertyType, bool> where);
         List<PropertyList> GetPropertyList(int By);
         List<PropertyList> GetPropertyList();
+        List<PropertyAdminContainer> GetAdminProperties(int UserId);
+        List<string> GetStatuses();
         void Insert(PropertyContainer items);
         PropertyContainer GetDetailed(int id, bool detailed);
         void Update(PropertyContainer item);

UnivateProperties_API/Repository/Properties/IUserDefinedGroupRepository.cs

         List<Group> GetFieldList(string propertyType, string name, int propertyID);
 
         List<Group> GetFieldListByPropType(string propertyType);
+
+        List<Group> GetSavedList(int PropertyId);
     }
 }

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

         public List<Property> Get(Func<Property, bool> where)
         {
             return dBContext.Properties
-                .Include("PropertyType")
-                .Include("Province")
-                .Include("City")
-                .Include("Suburb")
+                .Include("PropertyType")                
                 .Where(where).ToList();
         }
 
 
             var propertyDetails = new PropertyContainer();
 
+            propertyDetails.SalesTypeString = property.IsSale ? "Sale" : "Rental";            
+
             foreach (string prop in property.GetAllProperties())
             {
                 if (prop != "Item" && prop != "Display")
                     propertyDetails[prop] = property[prop];
-            }            
+            }
+
+            if (property.StatusId != null)
+                propertyDetails.StatusString = dBContext.Status.Where(s => s.Id == property.StatusId).FirstOrDefault()?.Description;
 
             propertyDetails.PropertyUsageType = propertyType.UsageType == PropertyUsageType.Commercial ? "Commercial" : "Residential";
 
 
         public void Update(Property item)
         {
-            if (item.Video.StartsWith("http"))
+            if (!string.IsNullOrEmpty(item.Video) && item.Video.StartsWith("http"))
                 item.Video = item.Video.Replace("https://www.youtube.com/watch?v=", "");
 
             dBContext.Entry(item).State = EntityState.Modified;
 
         public void Update(PropertyContainer item)
         {
-            if (item.Video.StartsWith("http"))
+            if (!string.IsNullOrEmpty(item.Video) && item.Video.StartsWith("http"))
                 item.Video = item.Video.Replace("https://www.youtube.com/watch?v=", "");
 
             var property = new Property();
             property.PropertyUserFields = null;
             property.PropertyImages = null;
 
+            if (!string.IsNullOrEmpty(item.StatusString))
+            {
+                property.StatusId = dBContext.Status.Where(s => s.Description == item.StatusString && s.StatusType == StatusType.Property).FirstOrDefault()?.Id;
+            }
+
             dBContext.Entry(property).State = EntityState.Modified;            
 
             #region Insert New UDFs
-
-            foreach (var propGroup in item.PropertyOverviewFields)
+          
+            foreach (var propGroup in item.PropertyFields)
             {
                 foreach (var field in propGroup.Fields)
                 {
-                    if (field.ItemId == 0)
-                    {                        
-                        var propertyField = new PropertyUserField()
-                        {                            
-                            PropertyId = property.Id,
-                            UserDefinedFieldId = field.Id,
-                            Value = field.Value
-                        };
-                        dBContext.Add(propertyField);                        
-                    }
-                    else
+                    if (field.Value != null)
                     {
-                        var propertyField = dBContext.PropertyUserFields.Where(p => p.Id == field.ItemId).FirstOrDefault();
-                        if (propertyField != null)
+                        var propField = dBContext.PropertyUserFields.Where(u => u.PropertyId == property.Id && u.UserDefinedFieldId == field.Id).FirstOrDefault();
+                        if (propField == null)
                         {
-                            if (string.IsNullOrEmpty(field.Value))
-                                propertyField.IsDeleted = true;
-                            else
-                                propertyField.Value = field.Value;
-
-                            dBContext.Entry(propertyField).State = EntityState.Modified;                            
+                            propField = new PropertyUserField()
+                            {
+                                PropertyId = property.Id,
+                                UserDefinedFieldId = field.Id,
+                                Value = field.Value
+                            };
+                            dBContext.Add(propField);
                         }
-                    }
-                }
-            }
-
-            foreach (var propGroup in item.PropertyFields)
-            {
-                foreach (var field in propGroup.Fields)
-                {
-                    if (field.ItemId == 0)
-                    {                        
-                        var propertyField = new PropertyUserField()
-                        {                            
-                            PropertyId = property.Id,
-                            UserDefinedFieldId = field.Id,
-                            Value = field.Value
-                        };
-                        dBContext.Add(propertyField);                        
-                    }
-                    else
-                    {
-                        var propertyField = dBContext.PropertyUserFields.Where(p => p.Id == field.ItemId).FirstOrDefault();
-                        if (propertyField != null)
+                        else
                         {
-                            if (string.IsNullOrEmpty(field.Value))
-                                propertyField.IsDeleted = true;
-                            else
-                                propertyField.Value = field.Value;
-
-                            dBContext.Entry(propertyField).State = EntityState.Modified;                            
+                            propField.Value = field.Value;
+                            dBContext.Entry(propField).State = EntityState.Modified;
                         }
-                    }
+                    }                    
                 }
             }
             #endregion
 
             #region Update Images            
 
-            if (item.PropertyImages != null)
+            if (item.NewImages != null)
             {
-                foreach (var image in item.PropertyImages)
+                var imgList = dBContext.PropertyImages.Where(p => p.PropertyId == property.Id).ToList();
+                foreach (var image in imgList)
+                {
+                    dBContext.Remove(image);
+                }
+
+                bool saveFiles = false;
+                var loc = dBContext.Location.FirstOrDefault()?.PropertyImageLocation;
+                if (!string.IsNullOrEmpty(loc))
                 {
-                    var propImage = dBContext.PropertyImages.Where(pi => pi.Id == image.Id).FirstOrDefault();
-                    if (propImage != null)
+                    saveFiles = true;
+                    loc += string.Format("\\{0}", property.Id);
+                    if (Directory.Exists(loc))
                     {
-                        propImage.IsDefault = image.IsDefault;
-                        propImage.IsDeleted = image.IsDeleted;
-                        dBContext.Entry(propImage).State = EntityState.Modified;
+                        Directory.CreateDirectory(loc);
+                    }
+                }
+
+                property.PropertyImages = new List<PropertyImage>();
+                var lastID = dBContext.PropertyImages.Max(i => i.Id) + 1;
+                foreach (var image in item.NewImages)
+                {
+                    var propImage = new PropertyImage
+                    {
+                        PropertyId = property.Id,
+                        Image = image.Image,
+                        IsDefault = image.IsDefault
+                    };
+
+                    if (saveFiles)
+                    {
+                        string path = ImageFormatter.Base64ToImage(propImage.Image, loc, lastID.ToString());
+                        propImage.Image = path;
                     }
+                    property.PropertyImages.Add(propImage);
+                    lastID++;
                 }
             }
 
         private List<PropertyDisplay> GetDisplayDetails(List<Property> props)
         {
             var properties = new List<PropertyDisplay>();
-            //Removed publish check for now
-            //props = props.Where(p => p.Published).ToList();
+            props = props.Where(p => p.Published).ToList();
             foreach (var item in props)
             {
                 PropertyDisplay display = new PropertyDisplay
 
         public List<PropertyDisplay> GetLatestDisplay()
         {
-            //Removed Published Check for now
-            //List<Property> props = GetAll().Where(x => x.Published).OrderByDescending(x => x.DatePublished).Take(3).ToList();
-            List<Property> props = GetAll().OrderByDescending(x => x.Created).Take(3).ToList();
+            List<Property> props = GetAll().Where(x => x.Published).OrderByDescending(x => x.DatePublished).Take(3).ToList();
             return GetDisplayDetails(props);
         }
 
         }
 
         public List<PropertyList> GetPropertyList()
-        {
-            //Removed Published check for now
-            //return SetPropertyList(dBContext.Properties.Where(x => x.Published).ToList());
-            return SetPropertyList(dBContext.Properties.ToList());
+        {           
+            return SetPropertyList(dBContext.Properties.Where(x => x.Published).ToList());
         }
 
         private List<PropertyList> SetPropertyList(List<Property> properties)
             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 status = dBContext.Status.Where(a => a.Code == "P1").FirstOrDefault();
+            var agent = dBContext.Agents.Where(a => a.UserId == items.UserId).FirstOrDefault();            
 
             foreach( string prop in property.GetAllProperties())
             {
                 property.AgentId = agent.Id;
             }            
 
-            if (status != null)
-                property.StatusId = status.Id;
+            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 (!string.IsNullOrEmpty(property.Video))
                 property.Video = property.Video.Replace("https://www.youtube.com/watch?v=", "");
                 property.DatePublished = DateTime.MinValue;
                 Update(property);
             }
-        }        
+        }
+
+        public List<PropertyAdminContainer> GetAdminProperties(int UserId)
+        {
+            var user = dBContext.Users.Where(u => u.Id == UserId).FirstOrDefault();
+            List<PropertyAdminContainer> returnProps = new List<PropertyAdminContainer>();
+            List<Property> props;
+            if ((user.Role.ToUpper() == "SUPER ADMIN"))
+            {
+                props = dBContext.Properties.Include("Owner").Include("PropertyType").ToList();
+            }
+            else
+            {
+                var indiv = dBContext.Individuals.Where(i => i.UserId == user.Id).FirstOrDefault();
+                props = dBContext.Properties.Include("Owner").Include("PropertyType").Where(p => p.OwnerId == indiv.Id).ToList();
+            }
+
+            foreach (var prop in props)
+            {
+                var propAdmin = new PropertyAdminContainer()
+                {
+                    Id = prop.Id,
+                    Owner = prop.Owner?.FullName,
+                    Property = prop.PropertyName,
+                    Reference = prop.PropertyRef,
+                    Unit = prop.Unit,
+                    Size = (from u in dBContext.PropertyUserFields
+                            join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
+                            where u.PropertyId == prop.Id
+                            && f.FieldName == "Floor Size"
+                            select u.Value).FirstOrDefault(),
+                    Price = prop.Price,
+                    Region = prop.Province,
+                    Town = prop.City,
+                    Suburb = prop.Suburb,
+                    IsPublished = prop.Published,
+                    Type = prop.PropertyType.UsageType.ToString()
+                };
+                
+                if (prop.StatusId != null)
+                {
+                    propAdmin.Status = dBContext.Status.Where(s => s.Id == prop.StatusId).FirstOrDefault()?.Description;
+                }
+
+                returnProps.Add(propAdmin);
+            }
+
+            return returnProps;
+        }
+
+        public List<string> GetStatuses()
+        {
+            return dBContext.Status.Where(s => s.StatusType == StatusType.Property).Select(s => s.Description).ToList();
+        }
     }
 }

UnivateProperties_API/Repository/Properties/UserDefinedGroupRepository.cs

             // Not sure if properties need it
             return 0;
         }
+
+        public List<Group> GetSavedList(int PropertyId)
+        {
+            var prop = dBContext.Properties.Include("PropertyType").Where(p => p.Id == PropertyId).FirstOrDefault();
+            var all = GetFieldListByPropType(prop.PropertyType.PropertyUsageType);
+
+            var groups = (from g in dBContext.UserDefinedGroups
+                          where g.UsageType == prop.PropertyType.UsageType
+                          || g.UsageType == PropertyUsageType.Both
+                          orderby g.Rank
+                          select g).ToList();
+
+            foreach (UserDefinedGroup uGroup in groups)
+            {
+                var groupFields = (from f in dBContext.PropertyUserFields
+                                   join uf in dBContext.UserDefinedFields on f.UserDefinedFieldId equals uf.Id
+                                   join g in dBContext.UserDefinedGroups on uf.GroupId equals g.Id
+                                   where f.PropertyId == PropertyId
+                                   && g.Id == uGroup.Id
+                                   orderby g.Rank, uf.Rank
+                                   select new { uf.FieldName, f.Value, f.Description }).ToList();
+
+                foreach (var val in groupFields)
+                {
+                    foreach (var iGroup in all)
+                    {
+                        foreach (var field in iGroup.Fields)
+                        {
+                            if (field.Name == val.FieldName)
+                            {
+                                field.Value = val.Value;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return all;
+        }
     }
 }

UnivateProperties_API/Startup.cs

             #endregion
             #region Financial 
             services.AddTransient<IPaygateRepository, PaygateRepository>();
+            services.AddTransient<IListingRepository, ListingRepository>(); 
             #endregion
             #region Misc
             services.AddTransient<ICarouselRepository, CarouselRepository>();