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

UnivateProperties_API/Containers/ProcessFlow/BidItemDisplay.cs

+namespace UnivateProperties_API.Containers.ProcessFlow
+{
+    public class BidItemDisplay
+    {
+        #region Properties
+        public int Id { get; set; }        
+        public string Type { get; set; }
+        public string ShortDescription { get; set; }
+        public string Description { get; set; }
+        public string Resort { get; set; }
+        public string Unit { get; set; }
+        public string Module { get; set; }
+        public string StatusCode { get; set; }
+        public string Status { get; set; }
+        public decimal Price { get; set; }
+        public decimal Offer { get; set; }
+        public string MadeBy { get; set; }
+        public string Comment { get; set; }
+        public string DeclineReason { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Containers/ProcessFlow/BitItemDecline.cs

+namespace UnivateProperties_API.Containers.ProcessFlow
+{
+    public class BitItemDecline
+    {
+        #region Proeprties
+        public int Id { get; set; }
+        public string Comment { get; set; }
+        #endregion 
+    }
+}

UnivateProperties_API/Controllers/ProcessFlow/BidController.cs

 using Microsoft.AspNetCore.Mvc;
 using System.Transactions;
+using UnivateProperties_API.Containers.ProcessFlow;
 using UnivateProperties_API.Model.ProcessFlow;
 using UnivateProperties_API.Repository;
+using UnivateProperties_API.Repository.ProccessFlow;
 
 namespace UnivateProperties_API.Controllers.ProcessFlow
 {
     [ApiController]
     public class BidController : ControllerBase
     {
-        private readonly IRepository<BidItem> _Repo;
+        private readonly IBidRepository _Repo;
 
-        public BidController(IRepository<BidItem> repo)
+        public BidController(IBidRepository repo)
         {
             _Repo = repo;
         }
             return new OkObjectResult(item);
         }
 
+        [HttpGet("GetBids/{name}")]
+        public IActionResult GetOwnerBids(string OwnerName)
+        {
+            var items = _Repo.GetAllBid();
+            return new OkObjectResult(items);
+        }
+
         [HttpPost]
         public IActionResult Post([FromBody] BidItem item)
         {
             }
         }
 
-        [HttpPut("{id}")]
+        [HttpPut]
         public IActionResult Put([FromBody] BidItem item)
         {
             if (item != null)
             return new NoContentResult();
         }
 
+        [HttpPut("AcceptBid/{id}")]
+        public IActionResult AcceptBid(int id)
+        {            
+            return new OkObjectResult(_Repo.AcceptBid(id));
+        }
+
+        [HttpPut("DeclineBid")]
+        public IActionResult DeclineBid([FromBody] BitItemDecline item)
+        {            
+            return new OkObjectResult(_Repo.DecineBid(item));
+        }
+
         [HttpDelete("{id}")]
         public IActionResult Delete(int id)
         {

UnivateProperties_API/Controllers/Properties/PropertyController.cs

                 }
                 else
                 {
-                    return new OkObjectResult(_Repo.GetPropertyList(x => proptypeIds.Contains(x.PropertyTypeId) && x.CreatedBy == by));
+                    //Needs to change to search on individule/Agent
+                    return new OkObjectResult(_Repo.GetPropertyList(x => proptypeIds.Contains(x.PropertyTypeId)));
                 }
             }
             else

UnivateProperties_API/Model/Properties/Property.cs

 namespace UnivateProperties_API.Model.Properties
 {
     public class Property : BaseEntity
-    {
-        private Property()
-        {
-
-        }
-
-        #region Properties
-        public string CreatedBy { get; set; }
+    {        
+        #region Properties        
         [ForeignKey("PropertyType")]        
         public int PropertyTypeId { get; set; }
         public string PropertyName { get; set; }

UnivateProperties_API/Repository/ProccessFlow/BidRepository.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using UnivateProperties_API.Containers.ProcessFlow;
 using UnivateProperties_API.Context;
 using UnivateProperties_API.Model.ProcessFlow;
 
 namespace UnivateProperties_API.Repository.ProccessFlow
 {
-    public class BidRepository : IRepository<BidItem>
+    public class BidRepository : IBidRepository
     {
         private readonly DataContext _dbContext;
 
             return GetAll();
         }
 
+        public List<BidItemDisplay> GetAllBid()
+        {
+            List<BidItem> bids = _dbContext.BidItems
+                .Include("Property")                
+                .Include("TimeshareWeek")
+                .Include("BidMaker")
+                .Include("Status")
+                .Include("Property.Owner")
+                .Include("Property.Agent")
+                .ToList();
+
+            return LoadDisplay(bids);
+        }
+
+        public List<BidItemDisplay> GetMyBid(Func<BidItem, bool> where)
+        {
+            List<BidItem> bids = _dbContext.BidItems
+                .Include("Property")
+                .Include("TimeshareWeek")
+                .Include("BidMaker")
+                .Include("Status")
+                .Where(where)
+                .ToList();
+
+            return LoadDisplay(bids);
+        }
+
+        private List<BidItemDisplay> LoadDisplay(List<BidItem> bids)
+        {
+            List<BidItemDisplay> list = new List<BidItemDisplay>();
+            foreach (BidItem item in bids)
+            {
+                BidItemDisplay bid = new BidItemDisplay()
+                {
+                    Id = item.Id,
+                    Offer = (decimal)item.Amount,
+                    Comment = item.Comment,
+                    DeclineReason = item.DeclinedReason
+                };
+     
+                if (item.PropertyId != null)
+                {
+                    bid.Type = "Property";
+                    bid.ShortDescription = item.Property.ShortDescription;
+                    bid.Description = item.Property.Description;
+                    bid.Price = item.Property.Price;
+                }
+                if (item.TimeshareWeekId != null)
+                {
+                    bid.Type = "Timeshare";
+                    bid.ShortDescription = string.Format("{0} {1} {2}", item.TimeshareWeek.ResortCode, item.TimeshareWeek.WeekNumber, item.TimeshareWeek.UnitNumber);
+                    bid.Price = (decimal)item.TimeshareWeek.SellPrice;
+                    bid.Resort = item.TimeshareWeek.ResortName;
+                    bid.Unit = item.TimeshareWeek.UnitNumber;
+                    bid.Module = item.TimeshareWeek.Module;
+                }
+                if (item.Status != null)
+                {
+                    bid.StatusCode = item.Status.Code;
+                    bid.Status = string.Format("{0} - {1}", item.Status.Code, item.Status.Description);
+                }
+                if (item.BidMaker != null)
+                    bid.MadeBy = item.BidMaker.Name + " " + item.BidMaker.Surname;
+
+                bid.MadeBy = "Bob";
+
+                list.Add(bid);
+
+            }
+            return list;
+        }
+
         public void Insert(BidItem item)
         {
+            var status = _dbContext.Status.Where(x => x.Code == "E1" && x.StatusType == StatusType.Bid).FirstOrDefault();
+            if (status != null)
+                item.StatusId = status.Id;
+
             _dbContext.Add(item);
             Save();
         }
             _dbContext.Entry(item).State = EntityState.Modified;
             Save();
         }
+
+        public BidItemDisplay AcceptBid(int id)
+        {            
+            var item = _dbContext.BidItems
+                .Include("Property")
+                .Include("TimeshareWeek")
+                .Include("BidMaker")
+                .Include("Status")
+                .Where(x => x.Id == id).FirstOrDefault();
+
+            var status =  (from s in _dbContext.Status
+                           where s.Code == "E2"
+                           && s.StatusType == StatusType.Bid
+                           select s).FirstOrDefault();
+
+            if (status != null)
+            {
+                item.StatusId = status.Id;                
+            }
+
+            _dbContext.Entry(item).State = EntityState.Modified;
+            Save();
+
+            List<BidItem> bids = new List<BidItem>() { item };
+            return LoadDisplay(bids).Find(x => x.Id == item.Id);
+        }
+
+        public BidItemDisplay DecineBid(BitItemDecline item)
+        {            
+            var bid = _dbContext.BidItems
+                .Include("Property")
+                .Include("TimeshareWeek")
+                .Include("BidMaker")
+                .Include("Status")
+                .Where(x => x.Id == item.Id).FirstOrDefault();
+
+            var status = (from s in _dbContext.Status
+                          where s.Code == "E3"
+                          && s.StatusType == StatusType.Bid
+                          select s).FirstOrDefault();
+
+            if (status != null)
+            {
+                bid.StatusId = status.Id;               
+            }
+
+            bid.DeclinedReason = item.Comment;
+
+            _dbContext.Entry(bid).State = EntityState.Modified;
+            Save();
+
+            List<BidItem> bids = new List<BidItem>() { bid };
+            return LoadDisplay(bids).Find(x => x.Id == bid.Id);
+        }
     }
 }

UnivateProperties_API/Repository/ProccessFlow/IBidRepository.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UnivateProperties_API.Containers.ProcessFlow;
+using UnivateProperties_API.Model.ProcessFlow;
+
+namespace UnivateProperties_API.Repository.ProccessFlow
+{
+    public interface IBidRepository : IRepository<BidItem>
+    {
+        List<BidItemDisplay> GetAllBid();
+        List<BidItemDisplay> GetMyBid(Func<BidItem, bool> where);
+        BidItemDisplay AcceptBid(int id);
+        BidItemDisplay DecineBid(BitItemDecline item);
+    }
+}

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

 
         public Property GetDetailed(Func<Property, bool> first)
         {
-            var property = dBContext.Properties.FirstOrDefault(first);
+            var property = dBContext.Properties.Include("Status").FirstOrDefault(first);
             if (property != null)
             {
                 GetDetail(ref property);

UnivateProperties_API/Startup.cs

             });
 
             #region ProcessFlow
-            services.AddTransient<IRepository<BidItem>, BidRepository>();
+            services.AddTransient<IBidRepository, BidRepository>();
             #endregion
             #region Property
             services.AddTransient<IRepository<Agent>, AgentRepository>();