Roles Update Part 1

UnivateProperties_API/Containers/Timeshare/Detailed/DetailedOwner.cs

                     HowMarried = "Partner";
                     break;
             }
+            User = individual.User;
+
             if (individual.Address != null)
             {
                 Address = individual.Address != null ? new DetailedAddress(individual.Address) : new DetailedAddress();
         public string SpouseCellnumber { get; set; }
         public DetailedAddress Address { get; set; }
         public DetailedBankDetails BankingDetails { get; set; }
+        public User User { get; set; }
     }
 }

UnivateProperties_API/Context/DataContext.cs

         public virtual DbSet<User> Users { get; set; }
         public virtual DbSet<Individual> Individuals { get; set; }
         public virtual DbSet<Address> Addresses { get; set; }
+        public virtual DbSet<UserRole> Roles { get; set; }
         #endregion User
 
         #region Communication

UnivateProperties_API/Controllers/Users/AgentController.cs

             return new OkObjectResult(_Repo.Get(x => x.Id == id));
         }
 
+        [HttpGet("single/{userId}")]
+        public IActionResult GetByUserId(int userId)
+        {
+            return new OkObjectResult(_Repo.Get(x => x.UserId == userId));
+        }
+
         [HttpPost()]
         public IActionResult Post([FromBody] AgentDto agentDto)
         {
             }
         }
 
+        [HttpPost("AgentFromUser")]
+        public IActionResult Post(int id, [FromBody] Agent agent)
+        {
+            using (var scope = new TransactionScope())
+            {
+                _Repo.Insert(agent);
+                scope.Complete();
+                return CreatedAtAction(nameof(Get), new { id = agent.Id }, agent);
+            }
+        }
+
         [HttpPut()]
         public IActionResult Put([FromBody] Agent agent)
         {

UnivateProperties_API/Controllers/Users/UserRoleController.cs

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

UnivateProperties_API/Migrations/20201019061752_UserRoles.cs

+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace UnivateProperties_API.Migrations
+{
+    public partial class UserRoles : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Roles",
+                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),
+                    RoleName = table.Column<string>(nullable: true),
+                    RoleDescription = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Roles", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Roles");
+        }
+    }
+}

UnivateProperties_API/Migrations/DataContextModelSnapshot.cs

                     b.ToTable("Users");
                 });
 
+            modelBuilder.Entity("UnivateProperties_API.Model.Users.UserRole", 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>("RoleDescription");
+
+                    b.Property<string>("RoleName");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles");
+                });
+
             modelBuilder.Entity("UnivateProperties_API.Model.Banks.BankAccount", b =>
                 {
                     b.HasOne("UnivateProperties_API.Model.Banks.Bank", "Bank")

UnivateProperties_API/Model/Users/Individual.cs

                         BankAccount.AccountHolder = owner.BankingDetails.AccountHolder;
                     }
                 }
+
+                if (owner.User != null)
+                {
+                    User.Role = owner.User.Role;
+                    User.LoginPasswordChange = owner.User.LoginPasswordChange;
+                }
             }
         }
         #endregion Methods

UnivateProperties_API/Model/Users/UserRole.cs

+namespace UnivateProperties_API.Model.Users
+{
+    public class UserRole : BaseEntity
+    {
+        public string RoleName { get; set; }
+        public string RoleDescription { get; set; }
+    }
+}

UnivateProperties_API/Repository/Properties/PropertyRepository.cs

             {
                 props = dBContext.Properties.Include("Owner").Include("PropertyType").ToList();
             }
+            else if (user.Role.ToUpper() == "AGENCY")
+            {
+                var agent = dBContext.Agents.Where(x => x.UserId == user.Id).FirstOrDefault();
+                props = dBContext.Properties.Include("Owner").Include("PropertyType").Where(x => x.AgencyId == agent.AgencyId).ToList();
+            }
             else
             {
                 var indiv = dBContext.Individuals.Where(i => i.UserId == user.Id).FirstOrDefault();

UnivateProperties_API/Repository/Timeshare/WeekRepository.cs

 
             var listIds = list.Select(x => x.WeekUni).ToList();
 
-            foreach (var  item in GetTenderWeeks())
+            foreach (var item in GetTenderWeeks())
             {
                 if (!listIds.Contains(item.WeekUni))
                     list.Add(item);

UnivateProperties_API/Repository/Users/AgentRepository.cs

 
         public void Insert(Agent item)
         {
-            item.Id = NewId();
-            item.User.Role = Role.Agent;
-            if (_dbContext.Agents.Any(a => a.AgencyId == null))
+            //item.Id = NewId();
+            //item.User.Role = Role.Agent;
+            /*if (_dbContext.Agents.Any(a => a.AgencyId == null))
             {
                 item.AgencyId = 10;
+            }*/
+            var agent = _dbContext.Agents.Where(x => x.Name == item.Name && x.Surname == item.Surname).FirstOrDefault();
+            var indiv = new Individual();
+
+            if (agent == null)
+            {
+                indiv = _dbContext.Individuals.Where(x => x.UserId == item.UserId).FirstOrDefault();
+                if (indiv != null)
+                {
+                    indiv.IsDeleted = true;
+                    _dbContext.Individuals.Update(indiv);
+                    _dbContext.SaveChanges();
+                }
+                item.Id = 0;
+                _dbContext.Agents.Add(item);
+                _dbContext.Users.Update(item.User);
+
+            }
+            else
+            {
+                if (agent.Name != item.Name)
+                {
+                    agent.Name = item.Name;
+                }
+                if (agent.Surname != item.Surname)
+                {
+                    agent.Surname = item.Surname;
+                }
+                if (agent.Email != item.Email)
+                {
+                    agent.Email = item.Email;
+                }
+                if (agent.Telephone != item.Telephone)
+                {
+                    agent.Telephone = item.Telephone;
+                }
+                if (agent.CellNumber != item.CellNumber)
+                {
+                    agent.CellNumber = item.CellNumber;
+                }
+                if (agent.AgencyId != item.AgencyId)
+                {
+                    agent.AgencyId = item.AgencyId;
+                }
+                _dbContext.Agents.Update(agent);
+                _dbContext.Users.Update(item.User);
             }
-            _dbContext.Add(item);
+            
             Save();
         }
 

UnivateProperties_API/Repository/Users/IndividualRepository.cs

 
         public List<Individual> GetAll()
         {
-            foreach(var item in _dbContext.Individuals.Include("User").Include("Address").Include("BankAccount").ToList())
+            foreach (var item in _dbContext.Individuals.Include("User").Include("Address").Include("BankAccount").ToList())
             {
                 var list = MyCommon.GetVisibleColumns(item);
             }
-            return _dbContext.Individuals.Include("User").ToList();
+            return _dbContext.Individuals.Include("User").Include("Address").ToList();
         }
 
         public Individual GetDetailed(Func<Individual, bool> first)
 
         public void Update(DetailedOwner item)
         {
-            var individual = _dbContext.Individuals.Include("Address").Include("BankAccount").FirstOrDefault(x => x.Id == item.Id);
+            var individual = _dbContext.Individuals.Include("User").Include("Address").Include("BankAccount").FirstOrDefault(x => x.Id == item.Id);
             if (individual != null)
             {
                 individual.UpdateFromDetailedOwner(item);

UnivateProperties_API/Repository/Users/UserRoleRepository.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnivateProperties_API.Context;
+using UnivateProperties_API.Model.Users;
+
+namespace UnivateProperties_API.Repository.Users
+{
+    public class UserRoleRepository : IRepository<UserRole>
+    {
+        private readonly DataContext _dbContext;
+
+        public UserRoleRepository(DataContext dbc)
+        {
+            _dbContext = dbc;
+        }
+
+
+        public List<UserRole> GetAll() 
+        {
+            return _dbContext.Roles.ToList();
+        }
+
+        public List<UserRole> Get(Func<UserRole, bool> where)
+        {
+            return _dbContext.Roles.Where(where).ToList();
+        }
+
+        public UserRole GetDetailed(Func<UserRole, bool> first)
+        {
+            return _dbContext.Roles.FirstOrDefault(first);
+        }
+
+        public List<UserRole> GetDetailedAll()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Insert(UserRole item)
+        {
+            if (item != null)
+            {
+                _dbContext.Roles.Add(item);
+                Save();
+            }
+        }
+
+        public void Insert(IEnumerable<UserRole> items)
+        {
+            if (items != null)
+            {
+                foreach (var item in items)
+                {
+                    _dbContext.Roles.Add(item);
+                }
+                Save();
+            }
+        }
+
+        public void Remove(UserRole item)
+        {
+            if (item != null)
+            {
+                _dbContext.Roles.Remove(item);
+                Save();
+            }
+        }
+
+        public void Remove(IEnumerable<UserRole> items)
+        {
+            if (items != null)
+            {
+                foreach (var item in items)
+                {
+                    _dbContext.Roles.Remove(item);
+                }
+                Save();
+            }
+        }
+
+        public void RemoveAtId(int item)
+        {
+            var role = _dbContext.Roles.Where(x => x.Id == item).FirstOrDefault();
+            _dbContext.Roles.Remove(role);
+            Save();
+        }
+
+        public void Update(UserRole item)
+        {
+            var curRole = _dbContext.Roles.Where(x => x.Id == item.Id).FirstOrDefault();
+
+            if (curRole != item)
+            {
+                _dbContext.Roles.Update(item);
+                Save();
+            }
+        }
+
+        public void Save()
+        {
+            _dbContext.SaveChanges();
+        }
+    }
+}

UnivateProperties_API/Startup.cs

             #region User
             services.AddScoped<IRegisterRepository, RegisterRepository>();
             services.AddTransient<IRepository<Agent>, AgentRepository>();
+            services.AddTransient<IRepository<UserRole>, UserRoleRepository>();
             services.AddTransient<IRegisterRepository, RegisterRepository>();
             services.AddTransient<IRepository<Agency>, AgencyRepository>();
             services.AddTransient<IUserRepository, UserRepository>();