PageRenderTime 52ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 0ms

/BC.Intercompany.Api/BC.Intercompany.Domain/DomainManager/UserManagementDomainManager.cs

https://bitbucket.org/abhishekmaitrey/bc.intercompanyportal
C# | 448 lines | 314 code | 105 blank | 29 comment | 22 complexity | 0999bb0e825df01e1e6a26bbfe829428 MD5 | raw file
  1. using BC.Intercompany.Domain.DataManager;
  2. using BC.Intercompany.Models;
  3. using System;
  4. using System.IO;
  5. using System.Collections.Generic;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9. using Newtonsoft.Json;
  10. using Newtonsoft.Json.Linq;
  11. using System.Linq;
  12. using System.Xml;
  13. using System.Xml.Linq;
  14. using BC.Intercompany.Domain.Enums;
  15. using System.Runtime.Caching;
  16. using System.Configuration;
  17. namespace BC.Intercompany.Domain.DomainManager
  18. {
  19. public class UserManagementDomainManager : IUserManagementDomainManager
  20. {
  21. private readonly IUserManagementDataManager _userDataManager;
  22. private readonly ICommonDomainManager _commonDomainManager;
  23. private readonly ICompanyCodeDomainManager _companyCodeDomainManager;
  24. public UserManagementDomainManager(IUserManagementDataManager userDataManager,
  25. ICommonDomainManager commonDomainManager, ICompanyCodeDomainManager companyCodeDomainManager)
  26. {
  27. this._userDataManager = userDataManager;
  28. this._commonDomainManager = commonDomainManager;
  29. this._companyCodeDomainManager = companyCodeDomainManager;
  30. }
  31. public async Task<IEnumerable<MenuModel>> GetAllMenusByRoleId(int roleId)
  32. {
  33. return await this._userDataManager.GetAllMenusByRoleId(roleId);
  34. }
  35. public async Task<UserManagementModel> FindUserAsync(string userName, string password)
  36. {
  37. //Call GetUser1
  38. //Call IsAuthenticated
  39. //If authentical and not present in DB, insert into DB, else pick data from db
  40. var userManagementModel = new UserManagementModel();
  41. userManagementModel = this._userDataManager.GetUser1(userName, password);
  42. if (!this._userDataManager.IsAuthenticated(userName, password))
  43. {
  44. //The user does not exist in AD, login not possible
  45. return userManagementModel;
  46. }
  47. else
  48. {
  49. //The user exists in AD, check if user available in DB
  50. var userModel = new UserManagementModel();
  51. try
  52. {
  53. userModel = await this._userDataManager.FindUserOnlyAsync(userName, password);
  54. }
  55. catch (Exception ex)
  56. {
  57. }
  58. if (String.IsNullOrEmpty(userModel.UserName))
  59. {
  60. //User not available in DB; Insert the user with guest role.
  61. userModel = _userDataManager.LoadADUsersByEmailId(userManagementModel.Email);
  62. _userDataManager.AddNewUserToDatabase(userModel);
  63. }
  64. }
  65. return await this._userDataManager.FindUserAsync(userName, password);
  66. }
  67. public async Task<IEnumerable<AuthoriserDetailsModel>> GetAllLimitsForAuthorisers(long UserId)
  68. {
  69. return await this._userDataManager.GetAllLimitsForAuthorisers(UserId);
  70. }
  71. public async Task<bool> AddADUer(UserManagementModel newUser)
  72. {
  73. return await this._userDataManager.AddADUer(newUser);
  74. }
  75. public async Task<ResultModel> SaveAuthoriserImportMessage(string Type, string Message)
  76. {
  77. return await this._userDataManager.SaveAuthoriserImportMessage(Type, Message);
  78. }
  79. public ResultModel SaveAuthoriserErrorMessage(string Type, string Message)
  80. {
  81. return this._userDataManager.SaveAuthoriserErrorMessage(Type, Message);
  82. }
  83. public async Task<ResultModel> AddUserLoginRecord(UserManagementModel userModel)
  84. {
  85. return await this._userDataManager.AddUserLoginRecord(userModel);
  86. }
  87. public async Task<IEnumerable<UserManagementModel>> SearchADUser(string SearchUsername)
  88. {
  89. return await this._userDataManager.SearchADUser(SearchUsername);
  90. }
  91. public async Task<UserManagementModel> LoadBlankUserDetails()
  92. {
  93. UserManagementModel objUserManagement = new UserManagementModel();
  94. objUserManagement.UserRolesList = await this._commonDomainManager.GetAllRoles();
  95. objUserManagement.CountryList = await this._commonDomainManager.GetAllCountries();
  96. return objUserManagement;
  97. }
  98. public bool CheckUserEmail_Exists(string email)
  99. {
  100. return _userDataManager.CheckUserEmail_Exists(email);
  101. }
  102. public async Task<ResultModel> CreateUser(UserManagementModel userModel)
  103. {
  104. ResultModel resultModel = new ResultModel();
  105. bool isClientEmailExists = this.CheckUserEmail_Exists(userModel.Email);
  106. if (isClientEmailExists)
  107. {
  108. resultModel.IsSuccessful = false;
  109. resultModel.ResponseMessage =
  110. "User with this email already exists into the system. User details not saved.";
  111. // This messages should be come from some constants file or some xml file.. we will do it later..
  112. return resultModel;
  113. }
  114. else
  115. {
  116. return await this._userDataManager.CreateUser(userModel);
  117. }
  118. }
  119. public async Task<ResultModel> UpdateAuthoriser(string xmlStream)
  120. {
  121. ResultModel resultModel = new ResultModel();
  122. List<UserManagementModel> sapUserList = new List<UserManagementModel>();
  123. sapUserList = await this.GetUserListFromSAPStram(xmlStream);
  124. resultModel = await this._userDataManager.SAVESAPAuthorisers(sapUserList);
  125. int batchjobid = resultModel.Id;
  126. if (batchjobid > 0)
  127. {
  128. resultModel = await this._userDataManager.MarkBatchJobDataInvalid(batchjobid);
  129. resultModel = await this.UpdateAuthoriserUsersFromSAP(batchjobid);
  130. }
  131. return resultModel;
  132. }
  133. private async Task<ResultModel> UpdateAuthoriserUsersFromSAP(int BatchjobMainId)
  134. {
  135. ResultModel resultModel = new ResultModel();
  136. IEnumerable<UserManagementModel> BatchJobListData = new List<UserManagementModel>();
  137. IEnumerable<UserManagementModel> AuthotisrList = new List<UserManagementModel>();
  138. BatchJobListData = await this._commonDomainManager.GetAllValidAuthoriserImportDataByMainId(BatchjobMainId);
  139. foreach (var batJobData in BatchJobListData)
  140. {
  141. UserManagementModel objModel = new UserManagementModel();
  142. objModel = await this.IsUserDataAlreadyExists(batJobData.SAP_USER_ID, batJobData.COMPANY_CODE, batJobData.RELEASE_ROLE, batJobData.EMAIL_ID);
  143. if (objModel == null)
  144. {
  145. resultModel = await this._userDataManager.InsertDataForAuthoriser(batJobData.BatchJobId);
  146. }
  147. else if (!String.IsNullOrEmpty(objModel.COMPANY_CODE))
  148. {
  149. //SAP returns status as string. We have stored status as boolean in table. Either active or in active..
  150. objModel.USER_STATUS = objModel.USER_STATUS == "Active" ? "Active" : "Inactive";
  151. if (objModel.VALID_TO_DATE != batJobData.VALID_TO_DATE || objModel.USER_STATUS.ToUpper() != batJobData.USER_STATUS.ToUpper())
  152. {
  153. resultModel = await this._userDataManager.UpdateAuthoriserDetailsFromSAP(objModel.AuthoriserLimitId, batJobData.BatchJobId);
  154. }
  155. }
  156. }
  157. AuthotisrList = await this._userDataManager.GetAllAuthoriserDataForBatchJobProcess();
  158. foreach (var objAuthoriserData in AuthotisrList)
  159. {
  160. UserManagementModel objModel = new UserManagementModel();
  161. resultModel = await this._userDataManager.DeleteAuthorisersFromSAP(objAuthoriserData.AuthoriserLimitId, BatchjobMainId);
  162. }
  163. return resultModel;
  164. }
  165. private async Task<UserManagementModel> IsUserDataAlreadyExists(string SAPUserName, string CompanyCode, string Release_Role, string Email)
  166. {
  167. UserManagementModel objUserManageModel = new UserManagementModel();
  168. return await this._userDataManager.IsAuthoriserDataExists(SAPUserName, CompanyCode, Release_Role, Email);
  169. }
  170. private async Task<List<UserManagementModel>> GetUserListFromSAPStram(string xmlStream)
  171. {
  172. List<UserManagementModel> userModelList = new List<UserManagementModel>();
  173. ResultModel resultModel = new ResultModel();
  174. XmlDocument xmlDoc = new XmlDocument();
  175. xmlDoc.LoadXml(xmlStream);
  176. XmlNodeList nodeList = xmlDoc.DocumentElement.SelectNodes("LIST_OF_PO_APPROVERS/ITEM");
  177. foreach (XmlNode node in nodeList)
  178. {
  179. UserManagementModel sapUserModel = new UserManagementModel();
  180. sapUserModel.USER_FIRST_NAME = node.SelectSingleNode("USER_FIRST_NAME").InnerText;
  181. sapUserModel.USER_LAST_NAME = node.SelectSingleNode("USER_LAST_NAME").InnerText;
  182. sapUserModel.COMPANY_CODE = node.SelectSingleNode("COMPANY_CODE").InnerText;
  183. sapUserModel.RELEASE_ROLE = node.SelectSingleNode("RELEASE_ROLE").InnerText;
  184. sapUserModel.USER_STATUS = node.SelectSingleNode("USER_STATUS").InnerText;
  185. sapUserModel.EMAIL_ID = node.SelectSingleNode("EMAIL_ID").InnerText;
  186. sapUserModel.SAP_USER_ID = node.SelectSingleNode("SAP_USER_ID").InnerText;
  187. if (!string.IsNullOrEmpty(node.SelectSingleNode("VALID_TO_DATE").InnerText.ToString()))
  188. sapUserModel.VALID_TO_DATE = Convert.ToDateTime(node.SelectSingleNode("VALID_TO_DATE").InnerText);
  189. sapUserModel.ALIAS = node.SelectSingleNode("ALIAS").InnerText;
  190. userModelList.Add(sapUserModel);
  191. }
  192. return userModelList;
  193. }
  194. public static string StreamToString(Stream str)
  195. {
  196. using (BinaryReader rdr = new BinaryReader(str))
  197. {
  198. using (MemoryStream mem = new MemoryStream())
  199. {
  200. byte[] buf = new byte[256];
  201. int bt;
  202. int bts = 0;
  203. while ((bt = rdr.Read(buf, 0, 256)) > 0)
  204. {
  205. mem.Write(buf, 0, bt);
  206. bts += bt;
  207. }
  208. mem.Position = 0;
  209. byte[] bytes = new byte[bts];
  210. mem.Read(bytes, 0, bytes.Length);
  211. return Encoding.ASCII.GetString(bytes);
  212. }
  213. }
  214. }
  215. public async Task<UserDetailsModel> LoadCurrentUserDetails(long userId)
  216. {
  217. return await this._userDataManager.LoadCurrentUserDetails(userId);
  218. }
  219. /*
  220. //This code will be used once we integrate import of authorisers from SAP, I am keeping it commented for future use..- Shailesh Gaikwad
  221. public async Task<UserDetailsModel> SearchDbForUserByEmail(string email)
  222. {
  223. // If exists, return User details from Db
  224. return await _userDataManager.SearchDbForUserByEmail(email);
  225. }
  226. */
  227. public async Task<UserDetailsModel> SearchDbForUserByEmail(string email)
  228. {
  229. // Check if User exists in Db
  230. if (_userDataManager.IsUserFoundInDb(email))
  231. {
  232. // If exists, return User details from Db
  233. return await _userDataManager.SearchDbForUserByEmail(email);
  234. }
  235. // If User doesn't exist in Db
  236. else
  237. {
  238. // Check if User exists in AD
  239. if (_userDataManager.IsUserFoundInAd(email))
  240. {
  241. // If exists in AD, find the user and store in DB
  242. try
  243. {
  244. // load user model from AD
  245. var userManagementModel = _userDataManager.LoadADUsersByEmailId(email);
  246. // Add User to Db
  247. _userDataManager.AddNewUserToDatabase(userManagementModel);
  248. // return User details from Db
  249. return await _userDataManager.SearchDbForUserByEmail(email);
  250. }
  251. catch (Exception ex)
  252. {
  253. return new UserDetailsModel();
  254. }
  255. }
  256. // If User does not exist in AD
  257. else
  258. {
  259. // Return empty User details object
  260. return new UserDetailsModel();
  261. }
  262. }
  263. }
  264. //
  265. public async Task<ResultModel> ToggleUser(string guid, bool status, long ModifiedBy)
  266. {
  267. return await this._userDataManager.ToggleUser(guid, status, ModifiedBy);
  268. }
  269. public async Task<UserManagementModel> GetUserDetailsFromDB(string guid)
  270. {
  271. return await this._userDataManager.GetUserDetailsFromDB(guid);
  272. }
  273. public async Task<IEnumerable<AuthoriserDetailsModel>> GetAllAuthorizers()
  274. {
  275. IEnumerable<AuthoriserDetailsModel> AuthoriserList;
  276. MemoryCache memoryCache = MemoryCache.Default;
  277. var res = memoryCache.Get("AuthoriserList");
  278. if (res != null)
  279. {
  280. return (IEnumerable<AuthoriserDetailsModel>)res;
  281. }
  282. else
  283. {
  284. AuthoriserList = await _userDataManager.GetAllAuthorizers();
  285. memoryCache.Add("AuthoriserList", AuthoriserList, DateTimeOffset.UtcNow.AddMinutes(60));
  286. return AuthoriserList;
  287. }
  288. }
  289. public async Task<IEnumerable<AuthoriserDetailsModel>> GetAllAuthorizersBySearchString(String SearchString)
  290. {
  291. return await _userDataManager.GetAllAuthorizersBySearchString(SearchString);
  292. }
  293. public async Task<IEnumerable<UserSelectModel>> GetAllUsersForHomePageSearch()
  294. {
  295. return await _userDataManager.GetAllUsersForHomePageSearch();
  296. }
  297. public async Task<IEnumerable<AuthoriserDetailsModel>> GetSpecificAuthorizersList(long AuthoriserId)
  298. {
  299. var Authorizers = await this._userDataManager.GetSpecificAuthorizersList(AuthoriserId);
  300. return Authorizers;
  301. }
  302. public async Task<IEnumerable<UserManagementModel>> GetAllUsers(int userId)
  303. {
  304. return await this._userDataManager.GetAllUsers(userId);
  305. }
  306. public async Task<UserManagementModel> GetUserDetails(string guid)
  307. {
  308. UserManagementModel objUser = new UserManagementModel();
  309. if (!string.IsNullOrEmpty(guid.Trim()))
  310. objUser = await this._userDataManager.GetUserDetails(guid);
  311. objUser.UserRolesList = await this.GetUserRolesWithoutAuthorizerAndRequestor();
  312. objUser.CountryList = await this._commonDomainManager.GetAllCountries();
  313. return objUser;
  314. }
  315. private async Task<IEnumerable<UserRoleModel>> GetUserRolesWithoutAuthorizerAndRequestor()
  316. {
  317. List<UserRoleModel> userRoles = await this._commonDomainManager.GetAllRoles() as List<UserRoleModel>;
  318. // userRoles.RemoveAll(x => x.RoleId == (int)Roles.AUTHORISER);
  319. userRoles.RemoveAll(x => x.RoleId == (int)Roles.GUEST);
  320. userRoles.RemoveAll(x => x.RoleId == (int)Roles.ADMIN);
  321. return userRoles;
  322. }
  323. public async Task<ResultModel> EditUser(UserManagementModel userModel)
  324. {
  325. var result = new ResultModel();
  326. try
  327. {
  328. return await this._userDataManager.EditUser(userModel);
  329. }
  330. catch (Exception ex)
  331. {
  332. result.IsSuccessful = false;
  333. result.ResponseMessage = ex.Message;
  334. return result;
  335. }
  336. }
  337. public async Task<ResultModel> DeleteUser(Guid guid)
  338. {
  339. return await this._userDataManager.DeleteUser(guid);
  340. }
  341. }
  342. }