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

UnivateProperties_API/Containers/Users/UserDto.cs

         public string Email { get; set; }
         public string Telephone { get; set; }
         public string CellNumber { get; set; }
+        public bool AcceptedTerms { get; set; }
     }
 }

UnivateProperties_API/Context/DataContext.cs

         public DbSet<Carousel> Carousel { get; set; }
         public DbSet<PlaceHolderFormat> PlaceHolderFormats { get; set; }
         public DbSet<Default> Defaults { get; set; }
+        public DbSet<TC> TermsConditions { get; set; }
         #endregion
 
         #region Payments

UnivateProperties_API/Controllers/Financial/RedirectController.cs

         {
             if (context.TRANSACTION_STATUS == 1)
             {
-                return Redirect("http://localhost:8080/#/payments/success");
+                return Redirect("http://training.provision-sa.com:122/#/payments/success");
             }
             else if (context.TRANSACTION_STATUS == 2)
             {
-                return Redirect("http://training.provision-sa.com:121/#/paymentError");
+                return Redirect("http://training.provision-sa.com:122/#/paymentError");
             }
             else
             {
-                return Redirect("http://localhost:8080/");
+                return Redirect("http://training.provision-sa.com:122/");
             }
 
         }

UnivateProperties_API/Controllers/Misc/TCController.cs

+using Microsoft.AspNetCore.Mvc;
+using UnivateProperties_API.Model.Misc;
+using UnivateProperties_API.Repository.Misc;
+
+namespace UnivateProperties_API.Controllers.Misc
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class TCController : ControllerBase
+    {
+        private readonly ITCRepository _repo;
+
+        public TCController(ITCRepository rp)
+        {
+            _repo = rp;
+        }
+        // GET: api/TC/5
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(_repo.GetTC());
+        }
+
+        // POST: api/TC
+        [HttpPost]
+        public IActionResult Post([FromBody] TC terms)
+        {
+            if (terms != null)
+            {
+                _repo.SetTC(terms);
+                return Ok();
+            }
+            else
+            {
+                return new NoContentResult();
+            }
+        }
+    }
+}

UnivateProperties_API/Migrations/20200911083801_TC.cs

+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class TC : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "TermsConditions",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
+                    Created = table.Column<DateTime>(nullable: false),
+                    Modified = table.Column<DateTime>(nullable: false),
+                    ModifiedBy = table.Column<string>(nullable: true),
+                    IsDeleted = table.Column<bool>(nullable: false),
+                    Version = table.Column<string>(nullable: true),
+                    TermsConditions = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TermsConditions", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "TermsConditions");
+        }
+    }
+}

UnivateProperties_API/Migrations/20200911094328_UserTC.cs

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

UnivateProperties_API/Migrations/DataContextModelSnapshot.cs

                     b.ToTable("PlaceHolderFormats");
                 });
 
+            modelBuilder.Entity("UnivateProperties_API.Model.Misc.TC", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("TermsConditions");
+
+                    b.Property<string>("Version");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TermsConditions");
+                });
+
             modelBuilder.Entity("UnivateProperties_API.Model.ProcessFlow.BidItem", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
                         .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
+                    b.Property<bool>("AcceptedTerms");
+
                     b.Property<DateTime>("Created");
 
                     b.Property<bool>("IsDeleted");

UnivateProperties_API/Model/Misc/TC.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace UnivateProperties_API.Model.Misc
+{
+    public class TC : BaseEntity
+    {
+        public string Version { get; set; }
+        public string TermsConditions { get; set; }
+    }
+}

UnivateProperties_API/Model/Users/User.cs

         public byte[] PasswordSalt { get; set; }
         public bool Verified { get; set; }
         public string Token { get; set; }
+        public bool AcceptedTerms { get; set; }
         #endregion Properties
 
         #region Methods

UnivateProperties_API/Repository/Communication/MailRepository.cs

 using MailKit.Net.Smtp;
 using MimeKit;
+using System;
+using System.Linq;
+using System.Linq.Dynamic.Core;
+using UnivateProperties_API.Context;
 using UnivateProperties_API.Model.Communication;
 
 namespace UnivateProperties_API.Repository.Communication
 
     public class MailRepository : IMailRepository
     {
+        private readonly DataContext _dbContext;
+
+        public MailRepository(DataContext db)
+        {
+            _dbContext = db;
+        }
+
         MimeMessage messageObj = new MimeMessage();
         MailboxAddress from;
         MailboxAddress to;
             string name = mm.Name;
             string email = mm.Email;
             string message = mm.Message;
-
+            var props = _dbContext.Properties.ToList();
+            var prop = props.Where(x => x.Id == Convert.ToInt32(mm.Property)).FirstOrDefault();
+            
             from = new MailboxAddress("Admin", mm.FromAddress);
 
             to = new MailboxAddress("User", mm.ToAddress);
                 "<h4>Email: " + email + "</h4>" +
                 "<h4>Phone: " + phone + "</h4>" +
                 "<div>" +
-                "<h4>Message: </h4>" +
-                "<p>" + message + "</p>" +
+                "<h4>Property: </h4>" +
+                "<p>" + prop.Id + "</p>" +
+                "<p>" + prop.PropertyName + "</p>" +
+                "<p>" + prop.PropertyRef + "</p>" +
+                "<p>" + prop.Price + "</p>" +
                 "</div>" +
                 "</div>" +
                 "</div>";

UnivateProperties_API/Repository/Misc/TCRepository.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Misc;
+
+namespace UnivateProperties_API.Repository.Misc
+{
+    public interface ITCRepository
+    {
+        void SetTC(TC terms);
+        TC GetTC();
+    }
+
+    public class TCRepository : ITCRepository
+    {
+        private readonly DataContext _dbContext;
+
+        public TCRepository(DataContext db)
+        {
+            _dbContext = db;
+        }
+
+        public void SetTC(TC terms)
+        {
+            var pulledTerms = _dbContext.TermsConditions.FirstOrDefault();
+            if (terms != null)
+            {
+                if (pulledTerms == null)
+                {
+                    _dbContext.TermsConditions.Add(terms);
+                    _dbContext.SaveChanges();
+                }
+                else
+                {
+                    pulledTerms.TermsConditions = terms.TermsConditions;
+                    pulledTerms.Version = terms.Version;
+
+                    _dbContext.TermsConditions.Update(pulledTerms);
+                    _dbContext.SaveChanges();
+                }
+                
+            }
+            
+        }
+
+        public TC GetTC()
+        {
+            return _dbContext.TermsConditions.FirstOrDefault();
+        }
+    }
+}

UnivateProperties_API/Repository/Users/IRegisterRepository.cs

     public interface IRegisterRepository
     {
         User Authenticate(string username, string password);
-        User Create(User user, string password, bool save);
+        User Create(User user, string password, bool save, bool terms);
         Agency CreateAgency(AgencyDto agency);
         void CreatePerson(UserDto individual, PersonType personType, bool save, Agency agency);
         void Update(User userParam, string password = null);

UnivateProperties_API/Repository/Users/RegisterRepository.cs

             return user;
         }
 
-        public User Create(User user, string password, bool save)
+        public User Create(User user, string password, bool save, bool terms)
         {
             // validation
             if (string.IsNullOrWhiteSpace(password))
 
             user.PasswordHash = passwordHash;
             user.PasswordSalt = passwordSalt;
+            user.AcceptedTerms = terms;
             //user.Id = NewUserId();
             _dbContext.Users.Add(user);
             if (save)
 
             User createUser = new User(individual.Username, individual.Password);
 
-            Create(createUser, individual.Password, false);
+            Create(createUser, individual.Password, false, individual.AcceptedTerms);
 
             Person p = null;
             

UnivateProperties_API/Startup.cs

             #endregion
             #region Misc
             services.AddTransient<ICarouselRepository, CarouselRepository>();
-            services.AddTransient<IRepository<PlaceHolderFormat>, PlaceHolderFormatRepository>();            
+            services.AddTransient<IRepository<PlaceHolderFormat>, PlaceHolderFormatRepository>();
+            services.AddTransient<ITCRepository, TCRepository>();
             #endregion
             #region Campaign 
             services.AddTransient<ICampaignRepository, CampaignRepository>();