Property Publish & payments

Property Flow (WIP)

UnivateProperties_API/Containers/Property/PropertyList.cs

         public int Id { get; set; }
         public DateTime DateAvailable { get; set; }
         public string Size { get; set; }
-        public string Price { get; set; }
+        public decimal 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; }
         public string CarouselDescription { get; set; }
+        public bool IsPublished { get; set; }
         #endregion
     }
 }

UnivateProperties_API/Context/DataContext.cs

 using Microsoft.EntityFrameworkCore;
-
-using UnivateProperties_API.Model.Communication;
-using UnivateProperties_API.Model.Users;
-using UnivateProperties_API.Model.Properties;
-using UnivateProperties_API.Model.Region;
-using UnivateProperties_API.Model.Timeshare;
+using Npgsql;
 using System.Linq;
 using UnivateProperties_API.Model;
 using UnivateProperties_API.Model.Banks;
+using UnivateProperties_API.Model.Communication;
+using UnivateProperties_API.Model.Financial;
+using UnivateProperties_API.Model.Logging;
 using UnivateProperties_API.Model.Misc;
 using UnivateProperties_API.Model.ProcessFlow;
-using UnivateProperties_API.Model.Logging;
-using Npgsql;
-using System;
+using UnivateProperties_API.Model.Properties;
+using UnivateProperties_API.Model.Region;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Model.Users;
 
 namespace UnivateProperties_API.Context
 {
         public DbSet<Carousel> Carousel { get; set; }
         #endregion
 
+        #region Payments
+        public DbSet<Payment> Payments { get; set; }
+        #endregion
+
         public override int SaveChanges()
         {
             foreach (var item in ChangeTracker

UnivateProperties_API/Controllers/Financial/PaymentController.cs

+using Microsoft.AspNetCore.Mvc;
+using System.Transactions;
+using UnivateProperties_API.Model.Financial;
+using UnivateProperties_API.Repository;
+
+namespace UnivateProperties_API.Controllers.Financial
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class PaymentController : ControllerBase
+    {
+        private readonly IRepository<Payment> _Repo;
+
+        public PaymentController(IRepository<Payment> _repo)
+        {
+            _Repo = _repo;
+        }
+        
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_Repo.GetAll());
+        }
+
+        [HttpGet("{id}")]
+        public IActionResult Get(int id)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.Id == id));
+        }
+        
+        [HttpPost]
+        public IActionResult Post([FromBody] Payment payment)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(payment);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = payment.Id }, payment);
+            }
+        }
+        
+        [HttpPut("{id}")]
+        public IActionResult Put([FromBody] Payment payment)
+        {
+            if (payment != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    _Repo.Update(payment);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }       
+    }
+}

UnivateProperties_API/Controllers/Properties/PropertyController.cs

             return new OkObjectResult(_Repo.GetPropertyList(by));
         }
 
+        [HttpGet("GetLivePropertyList")]
+        public IActionResult GetLivePropertyList()
+        {
+            return new OkObjectResult(_Repo.GetPropertyList());
+        }
+
         [HttpGet("MayEditProperty/{id}")]
         public IActionResult MayEditProperty(int id)
         {
                 }
             }
             return new NoContentResult();
-        }        
+        }
+        
+        [HttpPut("PublishProperty")]
+        public IActionResult PublishProperty([FromBody] PropertyDisplay property)
+        {
+            _Repo.PublishProperty(property.Id);
+            return new NoContentResult();
+        }
+
+        [HttpPut("UnpublishProperty")]
+        public IActionResult UnpublishProperty(PropertyDisplay property)
+        {
+            _Repo.UnpublishProperty(property.Id);
+            return new NoContentResult();
+        }
 
         [HttpDelete("{id}")]
         public IActionResult Delete(int id)

UnivateProperties_API/Migrations/20200121103350_PaymentsTable.cs

+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class PaymentsTable : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Payments",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
+                    Created = table.Column<DateTime>(nullable: false),
+                    Modified = table.Column<DateTime>(nullable: false),
+                    ModifiedBy = table.Column<string>(nullable: true),
+                    IsDeleted = table.Column<bool>(nullable: false),
+                    TimeshareWeekId = table.Column<int>(nullable: true),
+                    PropertyId = table.Column<int>(nullable: true),
+                    Amount = table.Column<decimal>(nullable: false),
+                    PaymentStatus = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Payments", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Payments_Properties_PropertyId",
+                        column: x => x.PropertyId,
+                        principalTable: "Properties",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_Payments_Weeks_TimeshareWeekId",
+                        column: x => x.TimeshareWeekId,
+                        principalTable: "Weeks",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Payments_PropertyId",
+                table: "Payments",
+                column: "PropertyId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Payments_TimeshareWeekId",
+                table: "Payments",
+                column: "TimeshareWeekId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Payments");
+        }
+    }
+}

UnivateProperties_API/Migrations/20200122063527_ExtraPaymentFields.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class ExtraPaymentFields : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "CreatedById",
+                table: "Payments",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<string>(
+                name: "PaymentToken",
+                table: "Payments",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Payments_CreatedById",
+                table: "Payments",
+                column: "CreatedById");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Payments_Users_CreatedById",
+                table: "Payments",
+                column: "CreatedById",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Payments_Users_CreatedById",
+                table: "Payments");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Payments_CreatedById",
+                table: "Payments");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedById",
+                table: "Payments");
+
+            migrationBuilder.DropColumn(
+                name: "PaymentToken",
+                table: "Payments");
+        }
+    }
+}

UnivateProperties_API/Migrations/20200122131033_DatePublishedToPorp.cs

+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class DatePublishedToPorp : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                name: "DatePublished",
+                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: "DatePublished",
+                table: "Properties");
+        }
+    }
+}

UnivateProperties_API/Migrations/DataContextModelSnapshot.cs

                     b.ToTable("Templates");
                 });
 
+            modelBuilder.Entity("UnivateProperties_API.Model.Financial.Payment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<decimal>("Amount");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<int>("CreatedById");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("PaymentStatus");
+
+                    b.Property<string>("PaymentToken");
+
+                    b.Property<int?>("PropertyId");
+
+                    b.Property<int?>("TimeshareWeekId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedById");
+
+                    b.HasIndex("PropertyId");
+
+                    b.HasIndex("TimeshareWeekId");
+
+                    b.ToTable("Payments");
+                });
+
             modelBuilder.Entity("UnivateProperties_API.Model.Logging.SearchLog", b =>
                 {
                     b.Property<int>("Id")
 
                     b.Property<DateTime>("DateAvailable");
 
+                    b.Property<DateTime>("DatePublished");
+
                     b.Property<string>("Description");
 
                     b.Property<bool>("IsDeleted");
                         .HasForeignKey("SenderId");
                 });
 
+            modelBuilder.Entity("UnivateProperties_API.Model.Financial.Payment", b =>
+                {
+                    b.HasOne("UnivateProperties_API.Model.Users.User", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedById")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("UnivateProperties_API.Model.Properties.Property", "Property")
+                        .WithMany()
+                        .HasForeignKey("PropertyId");
+
+                    b.HasOne("UnivateProperties_API.Model.Timeshare.TimeshareWeek", "TimeshareWeek")
+                        .WithMany()
+                        .HasForeignKey("TimeshareWeekId");
+                });
+
             modelBuilder.Entity("UnivateProperties_API.Model.Misc.Address", b =>
                 {
                     b.HasOne("UnivateProperties_API.Model.Users.Individual", "Owner")

UnivateProperties_API/Model/Financial/Payment.cs

+using System.ComponentModel.DataAnnotations.Schema;
+using UnivateProperties_API.Model.Properties;
+using UnivateProperties_API.Model.Timeshare;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Model.Financial
+{
+    public class Payment : BaseEntity
+    {
+        #region Properties
+        [ForeignKey("TimeshareWeek")]
+        public int? TimeshareWeekId { get; set; }
+        [ForeignKey("Property")]
+        public int? PropertyId { get; set; }
+        [ForeignKey("CreatedBy")]
+        public int CreatedById { get; set; }
+        public decimal Amount { get; set; }
+        public string PaymentStatus { get; set; }
+        public string PaymentToken { get; set; }
+
+
+        public virtual TimeshareWeek TimeshareWeek { get; set; }
+        public virtual Property Property { get; set; }
+        public virtual User CreatedBy { get; set; }
+        #endregion
+    }
+}

UnivateProperties_API/Model/Properties/Property.cs

         public int CityId { get; set; }
         public int ProvinceId { get; set; }
         public bool Published { get; set; }
+        public DateTime DatePublished { get; set; }
         public string VirtualTour { get; set; }
         public string Video { get; set; }
         [ForeignKey("Status")]

UnivateProperties_API/Repository/Financial/PaymentRepository.cs

+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Financial;
+
+namespace UnivateProperties_API.Repository.Financial
+{
+    public class PaymentRepository : IRepository<Payment>
+    {
+        private readonly DataContext _dbContext;
+
+        public PaymentRepository(DataContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public List<Payment> Get(Func<Payment, bool> where)
+        {
+            return _dbContext.Payments.Where(where).ToList();
+        }
+
+        public List<Payment> GetAll()
+        {
+            return _dbContext.Payments.OrderByDescending(p => p.Created).ToList();
+        }
+
+        public Payment GetDetailed(Func<Payment, bool> first)
+        {
+            var item = _dbContext.Payments.FirstOrDefault(first);
+            return item;
+        }
+
+        public List<Payment> GetDetailedAll()
+        {
+            return GetAll();
+        }        
+
+        public void Insert(Payment item)
+        {
+            _dbContext.Add(item);
+            Save();
+        }
+
+        public void Insert(IEnumerable<Payment> items)
+        {
+            foreach(var item in items)
+            {
+                _dbContext.Add(item);
+            }
+            Save();
+        }
+
+        public int NewId()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Remove(Payment item)
+        {
+            var i = _dbContext.Payments.Find(item);
+            _dbContext.Payments.Remove(i);
+            Save();
+        }
+
+        public void Remove(IEnumerable<Payment> items)
+        {
+            foreach (var item in items)
+            {
+                var i = _dbContext.Payments.Find(item);
+                _dbContext.Payments.Remove(i);                
+            }
+            Save();
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var i = _dbContext.Payments.Find(item);
+            _dbContext.Payments.Remove(i);
+            Save();
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+
+        public void Update(Payment item)
+        {
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

UnivateProperties_API/Repository/Misc/CarouselRepository.cs

         {
             string image = item.Image;
             item.Image = "";
+            item.Id = dBContext.GetMaxID("Carousel") + 1;
             dBContext.Add(item);
             Save();
 

UnivateProperties_API/Repository/Properties/IPropertyRepository.cs

         List<PropertyDisplay> GetLatestDisplay();
         List<PropertyType> GetPropertyTypes(Func<PropertyType, bool> where);
         List<PropertyList> GetPropertyList(int By);
+        List<PropertyList> GetPropertyList();
         void Insert(PropertyContainer items);
         PropertyContainer GetDetailed(int id, bool detailed);
         void Update(PropertyContainer item);
         bool MayEdit(int id);
         void InsertImages(int propertyID, List<PropertyImage> Images);
         void InsertFields(int propertyID, List<PropertyUserField> Fields);
+        void PublishProperty(int propertyID);
+        void UnpublishProperty(int propertyID);
     }
 }

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

                 Type = item.Type,
                 Search = JsonConvert.SerializeObject(item)
             };
+            searchLog.Id = dBContext.GetMaxID("SearchLogs") + 1;
             dBContext.SearchLogs.Add(searchLog);
             Save();
         }
         private List<PropertyDisplay> GetDisplayDetails(List<Property> props)
         {
             var properties = new List<PropertyDisplay>();
+            props = props.Where(p => p.Published).ToList();
             foreach (var item in props)
             {                
                 PropertyDisplay display = new PropertyDisplay
 
         public List<PropertyDisplay> GetLatestDisplay()
         {
-            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);
         }
 
                 }
                 if (user.Role.ToUpper() == "SUPER ADMIN")
                     properties = dBContext.Properties.Include("City").Include("Suburb").ToList();
-            }           
-            
+            }
+
+            return SetPropertyList(properties);
+        }
+
+        public List<PropertyList> GetPropertyList()
+        {
+            return SetPropertyList(dBContext.Properties.Where(x => x.Published).ToList());
+        }
+
+        private List<PropertyList> SetPropertyList(List<Property> properties)
+        {
             List<PropertyList> list = new List<PropertyList>();
 
             foreach (Property p in properties)
                 {
                     Id = p.Id,
                     Name = string.IsNullOrEmpty(p.PropertyName) ? p.ShortDescription : p.PropertyName,
-                    Price = string.Format("R {0:n}", p.Price),
-                    Publish = p.Published.ToString(),
+                    Price = p.Price,
+                    Publish = p.Published ? "Yes" : "No",
                     Type = dBContext.PropertyTypes.Find(p.PropertyTypeId)?.Description,
-                    CarouselDescription = string.Format("{0}, {1} <br/>{2}", p.Suburb.Description, p.City.Description, p.AddressLine3),
-                    DateAvailable = p.DateAvailable
+                    CarouselDescription = string.Format("{0}, {1} <br/>{2}", p.Suburb?.Description, p.City?.Description, p.AddressLine3),
+                    DateAvailable = p.IsSale ? DateTime.MinValue : p.DateAvailable,
+                    IsPublished = p.Published
                 };
 
                 prop.Size = (from u in dBContext.PropertyUserFields
 
                 list.Add(prop);
             }
-                
+
             return list;
         }
 
         {
             throw new NotImplementedException();
         }
+
+        public void PublishProperty(int propertyID)
+        {
+            var property = dBContext.Properties.Where(p => p.Id == propertyID).FirstOrDefault();
+            if (property != null)
+            {
+                property.Published = true;
+                property.DatePublished = DateTime.Now;
+                Update(property);
+            }
+        }
+
+        public void UnpublishProperty(int propertyID)
+        {
+            var property = dBContext.Properties.Where(p => p.Id == propertyID).FirstOrDefault();
+            if (property != null)
+            {
+                property.Published = false;
+                property.DatePublished = DateTime.MinValue;
+                Update(property);
+            }
+        }        
     }
 }

UnivateProperties_API/Startup.cs

 using UnivateProperties_API.Helpers;
 using UnivateProperties_API.Model.Banks;
 using UnivateProperties_API.Model.Communication;
+using UnivateProperties_API.Model.Financial;
 using UnivateProperties_API.Model.Misc;
 using UnivateProperties_API.Model.ProcessFlow;
 using UnivateProperties_API.Model.Properties;
 using UnivateProperties_API.Repository;
 using UnivateProperties_API.Repository.Banks;
 using UnivateProperties_API.Repository.Communication;
+using UnivateProperties_API.Repository.Financial;
 using UnivateProperties_API.Repository.Logging;
 using UnivateProperties_API.Repository.Misc;
 using UnivateProperties_API.Repository.ProccessFlow;
             services.AddTransient<IRepository<PropertyUserField>, PropertyUserFieldRepository>();
             services.AddTransient<IRepository<UserDefinedField>, UserDefinedFieldRepository>();
             services.AddTransient<IUserDefinedGroupRepository, UserDefinedGroupRepository>();
+            services.AddTransient<IRepository<Payment>, PaymentRepository>();
 
             #endregion Property
             #region Region