Add APISocietyToolBox source files

APISocietyToolBox/Controllers/BillsController.cs

@@ -0,0 +1,72 @@
+using APISocietyToolBox.Data;
+using APISocietyToolBox.Models;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Microsoft.Data.SqlClient;
+using Microsoft.AspNetCore.Authorization;
+
+
+namespace APISocietyToolBox.Controllers
+{
+	[Route("api/[controller]")]
+	[ApiController]
+	public class BillsController : Controller
+	{
+		private readonly DataContext _Context;
+		public BillsController(DataContext context)
+		{
+			_Context = context;
+		}
+
+		[HttpGet("GetMemberBillList"), Authorize]
+		public async Task<ActionResult<List<MemberBillsListModel>>> GetMemberBillList(Int32 PropertyID, Int32 PropertyUnitID, DateTime FromDate, DateTime ToDate)
+		{
+
+			try
+			{
+				var pQueryResponse = await _Context.GetMemberBillList
+					.FromSqlRaw("EXEC sp_getMemberBillList @PropertyID,@PropertyUnitID,@FromDate,@ToDate",
+						new SqlParameter("@PropertyID", System.Data.SqlDbType.BigInt) { Value = PropertyID },
+						new SqlParameter("@PropertyUnitID", System.Data.SqlDbType.BigInt) { Value = PropertyUnitID },
+						new SqlParameter("@FromDate", System.Data.SqlDbType.Date) { Value = FromDate },
+						new SqlParameter("@ToDate", System.Data.SqlDbType.Date) { Value = ToDate })
+					.ToListAsync();
+				
+
+
+				return Ok(pQueryResponse);
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, ex.Message);
+			}
+		}
+
+
+		[HttpGet("GetBillDetails"), Authorize]
+		public async Task<ActionResult<List<MemberBillsListModel>>> GetBillDetails(string BillID)
+		{
+
+			try
+			{
+				var pQueryResponse = await _Context.GetBillDetails
+					.FromSqlRaw("EXEC sp_getMemberBillList @BillID",
+						new SqlParameter("@BillID", System.Data.SqlDbType.VarChar) { Value = BillID })
+					.ToListAsync();
+
+
+
+				return Ok(pQueryResponse);
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, ex.Message);
+			}
+		}
+
+
+
+
+	}
+}

APISocietyToolBox/Controllers/DashboardController.cs

@@ -0,0 +1,69 @@
+using APISocietyToolBox.Data;
+using APISocietyToolBox.Models;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Cryptography;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Microsoft.Data.SqlClient;
+using Microsoft.AspNetCore.Authorization;
+
+namespace APISocietyToolBox.Controllers
+{
+	[Route("api/[controller]")]
+	[ApiController]
+	public class DashboardController : Controller
+	{
+		private readonly DataContext _Context;
+		public DashboardController(DataContext context)
+		{
+			_Context = context;
+		}
+				
+
+		[HttpGet("GetDashboardOutstandingSummary"), Authorize]
+		public async Task<ActionResult<List<DashBoardOutandingSummaryModel>>> GetDashboardOutstandingSummary(Int32 PropertyID, Int32 UserID)
+		{
+
+			try
+			{
+				var pQueryResponse = await _Context.getDashboardOutstandingSummary
+					.FromSqlRaw("EXEC sp_getDashboardMemberOustandingSummary @PropertyID,@UserID",
+						new SqlParameter("@PropertyID", System.Data.SqlDbType.BigInt) { Value = PropertyID },
+						new SqlParameter("@UserID", System.Data.SqlDbType.BigInt) { Value = UserID })
+					.ToListAsync();
+				//var summary = pQueryResponse.FirstOrDefault();
+
+
+				return Ok(pQueryResponse);
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, ex.Message);
+			}
+		}
+
+
+		[HttpGet("GetDashboardTransactions"),Authorize]
+		public async Task<ActionResult<List<DashBoardTransactionsModel>>> GetDashboardTransactions(Int32 PropertyID, Int32 UserID)
+		{
+
+			try
+			{
+				var pQueryResponse = await _Context.getDashboardTransactions
+					.FromSqlRaw("EXEC sp_getDashboardRecentTransactions @PropertyID,@UserID",
+						new SqlParameter("@PropertyID", System.Data.SqlDbType.BigInt) { Value = PropertyID },
+						new SqlParameter("@UserID", System.Data.SqlDbType.BigInt) { Value = UserID })
+					.ToListAsync();
+				var summary = pQueryResponse.FirstOrDefault();
+
+
+				return Ok(pQueryResponse);
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, ex.Message);
+			}
+		}
+
+	}
+}

APISocietyToolBox/Controllers/JWTAuthController.cs

@@ -0,0 +1,218 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Security.Cryptography;
+using APISocietyToolBox.Models;
+using APISocietyToolBox.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Data.SqlClient;
+
+namespace APISocietyToolBox.Controllers
+{
+	[Route("api/[controller]")]
+	[ApiController]
+	public class JWTAuthController : Controller
+	{
+		public static UserModel user = new UserModel();
+		private readonly IConfiguration _configuration;
+		//private readonly IUserService _userService;
+		private readonly DataContext _Context;
+
+		public JWTAuthController(IConfiguration configuration, DataContext context) //, IUserService userService
+		{
+			_configuration = configuration;
+			//_userService = userService;
+			_Context = context;
+		}
+
+		[HttpGet, Authorize]
+		public ActionResult<string> GetMe()
+		{
+			var userName = ""; // _userService.GetMyName();
+			return Ok(userName);
+		}
+
+		[HttpPost("login")]
+		public async Task<ActionResult<string>> Login(UserDto request)
+		{
+
+			var pUsername = new SqlParameter("@Username", request.Username);
+			var pQueryResponse = await _Context.LoginUserValidate.FromSqlRaw($"sp_ValidateUser @UserName", pUsername).ToListAsync();
+
+
+			if (pQueryResponse[0].UserName != request.Username)
+			{
+				return BadRequest("User not found.");
+			}
+
+			if (!VerifyPasswordHash(request.Password, pQueryResponse[0].LoginPassword, pQueryResponse[0].PasswordSalt))
+			{
+				return BadRequest("Wrong password.");
+			}
+
+			var Token = CreateToken(pQueryResponse[0]);
+
+			var refreshToken = GenerateRefreshToken();
+			user.UserID = pQueryResponse[0].UserID;
+			user.UserName = pQueryResponse[0].UserName;
+			user.UserRole = pQueryResponse[0].UserRole;
+			user.UserRoleID = pQueryResponse[0].UserRoleID;
+			user.PropertyID = pQueryResponse[0].PropertyID;
+			user.MemberID = pQueryResponse[0].MemberID;
+			user.RefreshToken = Token;
+			user.TokenExpires = refreshToken.Expires;
+			user.TokenCreated = refreshToken.Created;
+			
+
+
+			SetRefreshToken(user);
+
+			return Ok(user);
+		}
+
+		[HttpPost("refresh-token")]
+		public async Task<ActionResult<string>> RefreshToken(UserTokenRefreshModel user)
+		{
+			var pRefreshToken = new SqlParameter("@RefreshToken", user.RefreshToken);
+			var pQuery = _Context.getUserToken.FromSqlRaw($"sp_getUserToken @RefreshToken", pRefreshToken).ToList();
+			//Console.WriteLine(pQuery);
+			var pQueryResponse = await _Context.getUserToken.FromSqlRaw($"sp_getUserToken @RefreshToken", pRefreshToken).ToListAsync();
+
+			if (pQueryResponse[0].Status != 200)
+			{
+				return Unauthorized(pQueryResponse[0]);
+			}
+			else
+			{
+
+
+				string refreshToken = pQueryResponse[0].RefreshToken.ToString();
+
+				if (!user.RefreshToken.Equals(refreshToken))
+				{
+					return Unauthorized("Invalid Refresh Token.");
+				}
+				//else if (user.TokenExpires < DateTime.Now)
+				//{
+				//	return Unauthorized("Token expired.");
+				//}
+				LoginResponseModel usrResponse = new LoginResponseModel();
+				UserModel usr = new UserModel();
+				usrResponse.UserName = user.UserName!;
+				usrResponse.UserRole = user.UserRole!;
+
+				string token = CreateToken(usrResponse);
+				var newRefreshToken = GenerateRefreshToken();
+
+				usr.UserID = pQueryResponse[0].UserID;
+				usr.UserRoleID = pQueryResponse[0].UserRoleID;
+				usr.UserName = user.UserName!;
+				usr.UserRole = user.UserRole!;
+				usr.PropertyID = pQueryResponse[0].PropertyID;
+
+				usr.RefreshToken = token.ToString();
+				usr.TokenCreated = newRefreshToken.Created;
+				usr.TokenExpires = newRefreshToken.Expires;
+
+				SetRefreshToken(usr);
+
+				pQueryResponse[0].RefreshToken = usr.RefreshToken;
+				pQueryResponse[0].UserRole = user.UserRole;
+				pQueryResponse[0].UserName = user.UserName;
+				pQueryResponse[0].TokenCreated = newRefreshToken.Created;
+				pQueryResponse[0].TokenExpires = newRefreshToken.Expires;
+				//pQueryResponse[0].UserLocation=usr.UserLocation;
+
+				return Ok(pQueryResponse[0]);
+			}
+		}
+
+		private RefreshToken GenerateRefreshToken()
+		{
+			var refreshToken = new RefreshToken
+			{
+				Token = Convert.ToBase64String(RandomNumberGenerator.GetBytes(64)),
+				Expires = DateTime.Now.AddDays(1),
+				Created = DateTime.Now
+			};
+
+			return refreshToken;
+		}
+
+		private void SetRefreshToken(UserModel usr)
+		{
+			try
+			{
+
+
+				//Response.Cookies.Append("refreshToken", newRefreshToken.Token, cookieOptions);
+				UserTokensHistory oUserTokens = new UserTokensHistory();
+				oUserTokens.UserID = usr.UserID;
+				oUserTokens.UserRoleID = usr.UserRoleID;
+				oUserTokens.PropertyID = usr.PropertyID;
+				oUserTokens.RefreshToken = usr.RefreshToken;
+				oUserTokens.TokenCreated = usr.TokenCreated;
+				oUserTokens.TokenExpires = usr.TokenExpires;
+				
+
+				_Context.UserTokensHistory.Add(oUserTokens);
+				_Context.SaveChanges();
+			}
+			catch (Exception ex)
+			{
+				Console.WriteLine(ex.InnerException);
+			}
+		}
+
+		private string CreateToken(LoginResponseModel user)
+		{
+			List<Claim> claims = new List<Claim>
+			{
+				new Claim(ClaimTypes.Name, user.UserName),
+				new Claim(ClaimTypes.Role, user.UserRole)
+			};
+
+			var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes(_configuration.GetSection("AppSettings:Token").Value));
+
+			var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512);
+
+			var token = new JwtSecurityToken(
+				claims: claims,
+				expires: DateTime.Now.AddDays(1),
+				signingCredentials: creds);
+
+			var jwt = new JwtSecurityTokenHandler().WriteToken(token);
+
+			return jwt;
+		}
+
+
+
+		private bool VerifyPasswordHash(string password, string passwordHash, string passwordSalt)
+		{
+			byte[] pbytepasswordSalt = StringToByteArray(passwordSalt);
+			byte[] pbytepasswordHash = StringToByteArray(passwordHash);
+			using (var hmac = new HMACSHA512(pbytepasswordSalt))
+			{
+				var computedHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password));
+				return computedHash.SequenceEqual(pbytepasswordHash);
+			}
+		}
+		public static byte[] StringToByteArray(string hex)
+		{
+			int length = hex.Length / 2;
+			byte[] byteArray = new byte[length];
+			for (int i = 0; i < length; i++)
+			{
+				byteArray[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
+			}
+			return byteArray;
+		}
+
+
+
+	}
+}

APISocietyToolBox/Controllers/NoticeBoardController.cs

@@ -0,0 +1,132 @@
+using APISocietyToolBox.Data;
+using APISocietyToolBox.Models;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Microsoft.Data.SqlClient;
+using Microsoft.AspNetCore.Authorization;
+
+
+
+
+namespace APISocietyToolBox.Controllers
+{
+	[Route("api/[controller]")]
+	[ApiController]
+
+	public class NoticeBoardController : Controller
+	{
+		private readonly DataContext _Context;
+		public NoticeBoardController(DataContext context)
+		{
+			_Context = context;
+		}
+
+		[HttpPost("CreateNoticeMessage"), Authorize]
+		public async Task<ActionResult<ResponseNoticeBoardModel>> CreateNoticeMessage(Int32 PropertyID,Int32 UserID,string NoticeMessage)
+		{
+			try
+			{
+							
+				var pQueryResponse = await _Context.DbNoticeBoard.FromSqlRaw("EXEC sp_CreateNoticeMessage @PropertyID,@UserID,@NoticeMessage",
+				new SqlParameter("@PropertyID", System.Data.SqlDbType.BigInt) { Value = PropertyID },
+				new SqlParameter("@UserID", System.Data.SqlDbType.BigInt) { Value = UserID },
+				new SqlParameter("@NoticeMessage", System.Data.SqlDbType.VarChar) { Value = NoticeMessage })
+				.ToListAsync();
+				var summary = pQueryResponse.FirstOrDefault();
+
+				if (pQueryResponse[0].Status != 200)
+				{
+					return BadRequest(summary);
+				}
+				else
+				{
+					return Ok(summary);
+				}
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, (ex.Message));
+			}
+		}
+
+		[HttpPut("UpdateNoticeMessage"), Authorize]
+		public async Task<ActionResult<ResponseNoticeBoardModel>> UpdateNoticeMessage(Int32 PropertyID, Int32 UserID, string NoticeMessage, Int32 NoticeID)
+		{
+			try
+			{
+
+				var pQueryResponse = await _Context.DbNoticeBoard.FromSqlRaw("EXEC sp_AlterNoticeMessage @PropertyID,@UserID,@NoticeMessage,@NoticeID",
+				new SqlParameter("@PropertyID", System.Data.SqlDbType.BigInt) { Value = PropertyID },
+				new SqlParameter("@UserID", System.Data.SqlDbType.BigInt) { Value = UserID },
+				new SqlParameter("@NoticeMessage", System.Data.SqlDbType.VarChar) { Value = NoticeMessage },
+				new SqlParameter("@NoticeID", System.Data.SqlDbType.BigInt) { Value = NoticeID })
+				.ToListAsync();
+				var summary = pQueryResponse.FirstOrDefault();
+
+				if (pQueryResponse[0].Status != 200)
+				{
+					return BadRequest(summary);
+				}
+				else
+				{
+					return Ok(summary);
+				}
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, (ex.Message));
+			}
+		}
+
+		[HttpDelete("DeleteNoticeMessage"), Authorize]
+		public async Task<ActionResult<ResponseNoticeBoardModel>> DeleteNoticeMessage(Int64 NoticeID, Int64 UserID)
+		{
+			try
+			{
+
+
+				var pQueryResponse = await _Context.DbNoticeBoard.FromSqlRaw("EXEC sp_DeleteNoticeMessage @NoticeID,@UserID",
+				new SqlParameter("@NoticeID", System.Data.SqlDbType.BigInt) { Value = NoticeID },
+				new SqlParameter("@UserID", System.Data.SqlDbType.BigInt) { Value = UserID })
+				.ToListAsync();
+
+				var summary = pQueryResponse.FirstOrDefault();
+
+				if (pQueryResponse[0].Status != 200)
+				{
+					return BadRequest(summary);
+				}
+				else
+				{
+					return Ok(summary);
+				}
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500,(ex.Message));
+			}
+		}
+
+
+		[HttpGet("GetNoticeMessageList"), Authorize]
+		public async Task<ActionResult<List<NoticeBoardMessageModel>>> GetNoticeMessageList(Int64 PropertyID)
+		{
+			try
+			{
+				
+				var pQueryResponse = await _Context.GetNoticeBoardMessages.FromSqlRaw("EXEC sp_getNoticeMessagesList @PropertyID",				
+				new SqlParameter("@PropertyID", System.Data.SqlDbType.BigInt) { Value = PropertyID })
+				.ToListAsync();
+
+
+				return Ok(pQueryResponse);
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, (ex.Message));
+			}
+		}
+
+	}
+}

APISocietyToolBox/Controllers/PropertyUnitsController.cs

@@ -0,0 +1,42 @@
+using APISocietyToolBox.Data;
+using APISocietyToolBox.Models;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Microsoft.Data.SqlClient;
+using Microsoft.AspNetCore.Authorization;
+namespace APISocietyToolBox.Controllers
+{
+	[Route("api/[controller]")]
+	[ApiController]
+
+	public class PropertyUnitsController : Controller
+	{
+		private readonly DataContext _Context;
+		public PropertyUnitsController(DataContext context)
+		{
+			_Context = context;
+		}
+
+		[HttpGet("GetPropertyUnitsForUser"), Authorize]
+		public async Task<ActionResult<List<NoticeBoardMessageModel>>> GetPropertyUnitsForUser(Int64 UserID)
+		{
+			try
+			{
+
+				var pQueryResponse = await _Context.GetPropertyUnitsForUsers.FromSqlRaw("EXEC sp_getPropertyUnitsForUser @UserID",
+				new SqlParameter("@UserID", System.Data.SqlDbType.BigInt) { Value = UserID })
+				.ToListAsync();
+
+
+				return Ok(pQueryResponse);
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, (ex.Message));
+			}
+		}
+
+
+	}
+}

APISocietyToolBox/Controllers/ReportsController.cs

@@ -0,0 +1,45 @@
+using APISocietyToolBox.Data;
+using APISocietyToolBox.Models;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Cryptography;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Microsoft.Data.SqlClient;
+using Microsoft.AspNetCore.Authorization;
+
+namespace APISocietyToolBox.Controllers
+{
+	[Route("api/[controller]")]
+	[ApiController]
+
+	public class ReportsController : Controller
+	{
+		private readonly DataContext _Context;
+		public ReportsController(DataContext context)
+		{
+			_Context = context;
+		}
+
+		[HttpGet("GetPropertyUnitLedgerReport"), Authorize]
+		public async Task<ActionResult<List<PropertyUnitLedgerReportsModel>>> GetPropertyUnitLedgerReport( Int32 PropertyUnitID, DateTime FromDate, DateTime ToDate)
+		{
+
+			try
+			{
+					var pQueryResponse = await _Context.GetPropertyUnitLedgerReport
+					.FromSqlRaw("EXEC sp_GeneratePropertyUnitLedger @FromDate,@ToDate,@PropertyUnitID",
+						new SqlParameter("@FromDate", System.Data.SqlDbType.Date) { Value = FromDate },
+						new SqlParameter("@ToDate", System.Data.SqlDbType.Date) { Value = ToDate },
+						new SqlParameter("@PropertyUnitID", System.Data.SqlDbType.BigInt) { Value = PropertyUnitID })
+					.ToListAsync();
+				
+
+				return Ok(pQueryResponse);
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, ex.Message);
+			}
+		}
+	}
+}

APISocietyToolBox/Controllers/TransactionsController.cs

@@ -0,0 +1,52 @@
+using APISocietyToolBox.Data;
+using APISocietyToolBox.Models;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Cryptography;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Microsoft.Data.SqlClient;
+using Microsoft.AspNetCore.Authorization;
+
+
+
+namespace APISocietyToolBox.Controllers
+{
+	[Route("api/[controller]")]
+	[ApiController]
+	public class TransactionsController : Controller
+	{
+		private readonly DataContext _Context;
+		public TransactionsController(DataContext context)
+		{
+			_Context = context;
+		}
+
+
+		[HttpGet("GetMemberTransactionList"), Authorize]
+		public async Task<ActionResult<List<MemberTransactionsListModel>>> GetMemberTransactionList(Int32 PropertyID, Int32 PropertyUnitID,Int32 TransactionTypeID,DateTime FromDate,DateTime ToDate)
+		{
+
+			try
+			{
+				var pQueryResponse = await _Context.GetMemberTransactionsList
+					.FromSqlRaw("EXEC sp_getMemberTransactionList @PropertyID,@PropertyUnitID,@TransactionTypeID,@FromDate,@ToDate",
+						new SqlParameter("@PropertyID", System.Data.SqlDbType.BigInt) { Value = PropertyID },
+						new SqlParameter("@PropertyUnitID", System.Data.SqlDbType.BigInt) { Value = PropertyUnitID },
+						new SqlParameter("@TransactionTypeID", System.Data.SqlDbType.BigInt) { Value = TransactionTypeID },
+						new SqlParameter("@FromDate", System.Data.SqlDbType.Date) { Value = FromDate },
+						new SqlParameter("@ToDate", System.Data.SqlDbType.Date) { Value = ToDate })
+					.ToListAsync();
+				var summary = pQueryResponse.FirstOrDefault();
+
+
+				return Ok(pQueryResponse);
+			}
+			catch (Exception ex)
+			{
+				return StatusCode(500, ex.Message);
+			}
+		}
+
+
+	}
+}

APISocietyToolBox/Controllers/UsersController.cs

@@ -0,0 +1,137 @@
+using APISocietyToolBox.Data;
+using APISocietyToolBox.Models;
+using APISocietyToolBox.Functions;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Cryptography;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Microsoft.Data.SqlClient;
+
+namespace APISocietyToolBox.Controllers
+{
+	[Route("api/[controller]")]
+	[ApiController]
+	public class UsersController : Controller
+	{
+		private readonly DataContext _Context;
+
+		public UsersController(DataContext context)
+		{
+			_Context = context;
+		}
+
+		[HttpPost("CreateUser")]
+		public async Task<ActionResult<string>> CreateUser(UserRequestModel UserRequest)
+		{
+			CreatePasswordHash(UserRequest.LoginPassword, out byte[] passwordHash, out byte[] passwordSalt);
+			UserModel User = new UserModel();
+			User.UserID = UserRequest.UserID;
+			User.UserName = UserRequest.UserName;
+			User.UserRole = UserRequest.UserRole;
+			User.UserRoleID = UserRequest.UserRoleID;
+			User.LoginName = UserRequest.LoginName;
+			User.LoginPassword = BitConverter.ToString(passwordHash).Replace("-", "");
+			User.PasswordSalt = BitConverter.ToString(passwordSalt).Replace("-", "");// System.Text.Encoding.UTF8.GetString(passwordSalt);
+			User.MemberID = UserRequest.MemberID;
+			User.PropertyID = UserRequest.PropertyID;
+			string pStrJSONUser = JsonConvert.SerializeObject(User);
+			//pStrJSONUser = Regex.Replace(pStrJSONUser, @"[^\x20-\x7E]", "");
+			string pStrUserXML = ConvertFunctions.ConvertJsonToXmlR2(pStrJSONUser, "USER", "USERDETAILS");
+			//UserResponseModel UserResponse = new UserResponseModel();
+			var pQueryResponse = await _Context.UserCRUD.FromSqlRaw("EXEC sp_CreateUser @XMLUserData",
+				new SqlParameter("@XMLUserData", System.Data.SqlDbType.Xml) { Value = pStrUserXML })
+				.ToListAsync();
+			//var oUserResponse = JsonConvert.DeserializeObject<UserResponseModel>(pQueryResponse?.ToString());
+
+
+
+			if (pQueryResponse[0].Status == 200)
+			{
+				return Ok(pQueryResponse);
+			}
+			else
+			{
+				return BadRequest(pQueryResponse);
+			}
+
+
+		}
+
+		[HttpPut("AlterUser")]
+		public async Task<ActionResult<string>> AlterUser(UserRequestModel UserRequest)
+		{
+			CreatePasswordHash(UserRequest.LoginPassword, out byte[] passwordHash, out byte[] passwordSalt);
+			UserModel User = new UserModel();
+			User.UserID = UserRequest.UserID;
+			User.UserName = UserRequest.UserName;
+			User.UserRole = UserRequest.UserRole;
+			User.UserRoleID = UserRequest.UserRoleID;
+			User.LoginName = UserRequest.LoginName;
+			User.LoginPassword = BitConverter.ToString(passwordHash).Replace("-", "");
+			User.PasswordSalt = BitConverter.ToString(passwordSalt).Replace("-", "");// System.Text.Encoding.UTF8.GetString(passwordSalt);
+
+			User.PropertyID = UserRequest.PropertyID;
+			string pStrJSONUser = JsonConvert.SerializeObject(User);
+			//pStrJSONUser = Regex.Replace(pStrJSONUser, @"[^\x20-\x7E]", "");
+			string pStrUserXML = ConvertFunctions.ConvertJsonToXmlR2(pStrJSONUser, "USER", "USERDETAILS");
+			//UserResponseModel UserResponse = new UserResponseModel();
+			var pQueryResponse = await _Context.UserCRUD.FromSqlRaw("EXEC sp_AlterUser @XMLUserData",
+				new SqlParameter("@XMLUserData", System.Data.SqlDbType.Xml) { Value = pStrUserXML })
+				.ToListAsync();
+			//var oUserResponse = JsonConvert.DeserializeObject<UserResponseModel>(pQueryResponse?.ToString());
+
+
+
+			if (pQueryResponse[0].Status == 200)
+			{
+				return Ok(pQueryResponse);
+			}
+			else
+			{
+				return BadRequest(pQueryResponse);
+			}
+
+
+		}
+
+		[HttpPut("UpdateUserMemberMapping")]
+		public async Task<ActionResult<string>> UpdateUserMemberMapping(List<UserMemberMappingModel> UserMappingRequest)
+		{
+			
+			string pStrJSONUser = JsonConvert.SerializeObject(UserMappingRequest);
+			//pStrJSONUser = Regex.Replace(pStrJSONUser, @"[^\x20-\x7E]", "");
+			string pStrUserXML = ConvertFunctions.ConvertJsonArrayToXmlR1(pStrJSONUser, "USER", "USERMAPPINGDETAILS");
+			//UserResponseModel UserResponse = new UserResponseModel();
+			var pQueryResponse = await _Context.UserCRUD.FromSqlRaw("EXEC sp_UpdateUserMapping @XMLData",
+				new SqlParameter("@XMLData", System.Data.SqlDbType.Xml) { Value = pStrUserXML })
+				.ToListAsync();
+			//var oUserResponse = JsonConvert.DeserializeObject<UserResponseModel>(pQueryResponse?.ToString());
+
+
+
+			if (pQueryResponse[0].Status == 200)
+			{
+				return Ok(pQueryResponse);
+			}
+			else
+			{
+				return BadRequest(pQueryResponse);
+			}
+
+
+		}
+
+
+
+		private void CreatePasswordHash(string password, out byte[] passwordHash, out byte[] passwordSalt)
+		{
+			using (var hmac = new HMACSHA512())
+			{
+				passwordSalt = hmac.Key;
+				passwordHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password));
+			}
+		}
+
+
+	}
+}

APISocietyToolBox/Controllers/WeatherForecastController.cs

@@ -0,0 +1,33 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace APISocietyToolBox.Controllers
+{
+	[ApiController]
+	[Route("[controller]")]
+	public class WeatherForecastController : ControllerBase
+	{
+		private static readonly string[] Summaries = new[]
+		{
+		"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
+	};
+
+		private readonly ILogger<WeatherForecastController> _logger;
+
+		public WeatherForecastController(ILogger<WeatherForecastController> logger)
+		{
+			_logger = logger;
+		}
+
+		[HttpGet(Name = "GetWeatherForecast")]
+		public IEnumerable<WeatherForecast> Get()
+		{
+			return Enumerable.Range(1, 5).Select(index => new WeatherForecast
+			{
+				Date = DateTime.Now.AddDays(index),
+				TemperatureC = Random.Shared.Next(-20, 55),
+				Summary = Summaries[Random.Shared.Next(Summaries.Length)]
+			})
+			.ToArray();
+		}
+	}
+}