public ActionResult CreateAccount(UserVM model)
{
// Check model state
if (!ModelState.IsValid)
{
return(View("CreateAccount", model));
}
// Check if passwords match
if (!model.Password.Equals(model.ConfirmPassword))
{
ModelState.AddModelError("", "Passwords do not match.");
return(View("CreateAccount", model));
}
using (Db db = new Db())
{
// Make sure username is unique
if (db.Users.Any(x => x.Username.Equals(model.Username)))
{
ModelState.AddModelError("", "Username " + model.Username + " is taken.");
model.Username = "";
return(View("CreateAccount", model));
}
// Create userDTO
UserDTO userDTO = new UserDTO()
{
FirstName = model.FirstName,
LastName = model.LastName,
EmailAddress = model.EmailAddress,
Username = model.Username,
Password = model.Password
};
// Add the DTO
db.Users.Add(userDTO);
// Save
db.SaveChanges();
// Add to UserRolesDTO
int id = userDTO.Id;
UserRolesDTO userRolesDTO = new UserRolesDTO()
{
UserId = id,
RoleId = 2
};
db.UserRoles.Add(userRolesDTO);
db.SaveChanges();
}
// Create a TempData message
TempData["SM"] = "You are now registered and can login.";
// Redirect
return(Redirect("~/account/login"));
}
public async Task <ActionResult> Index(User user)
{
var loginResultData = new UserRolesDTO();
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
//string baseUri = _settings.ApiUrl + "/" + Constants.Token + "/";
string baseUri = "https://webapilatesttal.azurewebsites.net/" + Constants.Token + "/";
client.BaseAddress = new Uri(baseUri);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = await client.PostAsJsonAsync(baseUri, user);
var result = response.Content.ReadAsStringAsync().Result;
loginResultData = JsonConvert.DeserializeObject <UserRolesDTO>(result);
}
}
if (loginResultData != null && loginResultData.Token != null)
{
HttpContext.Session.SetString("JWTToken", loginResultData.Token);
HttpContext.Session.SetString("UserName", loginResultData.Username);
HttpContext.Session.SetString("RoleName", loginResultData.RoleName);
return(await Task.FromResult(RedirectToAction("Index", "Dashboard")));
}
else
{
ViewBag.message = "Invalid username and password!";
return(await Task.FromResult(View()));
}
}
public async Task <ActionResult> AddNewRole([FromBody] UserRolesDTO userRolesDTO)
{
try
{
if (userRolesDTO != null)
{
AspNetRoles aspNetRole = new AspNetRoles()
{
Id = Guid.NewGuid().ToString(),
Name = userRolesDTO.RoleName,
NormalizedName = userRolesDTO.RoleName.ToUpper()
};
await _userRepo.AddnewRole(aspNetRole);
return(new StatusCodeResult(200));
}
else
{
return(new StatusCodeResult(400));
}
}catch (Exception ex)
{
return(new StatusCodeResult(400));
}
}
public IQueryable <SitePermissionsDTO> GetPermissionByUserAndRole(UserRolesDTO userRoles)
{
List <Guid> Roles = userRoles.Roles.Select(o => o.Id).ToList();
////PermissionMaster permissionMaster = await db.PermissionMasters.FindAsync(id);
//var permissionMaster = await (from permMaster in db.PermissionMasters
// join siteMapRolePermission in db.SiteMapRolePermissions on permMaster.Id equals siteMapRolePermission.PermissionId
// join userRolesMap in db.UserRolesMaps on siteMapRolePermission.RoleId equals userRolesMap.RoleId
// join userMaster in db.UserMasters on userRolesMap.UserId equals userMaster.Id
// where userMaster.Id.Equals(userRoles.UserId) && Roles.Contains(userRolesMap.RoleId)
// select new PermissionMasterDTO
// {
// Id = permMaster.Id,
// Name = permMaster.Name
// }).Distinct().ToListAsync();
int SiteMapTypeId = (int)EMPConstants.SitemapType.Admin;
var sitePermissionList = (from siteroleper in db.SiteMapRolePermissions
join permisionSite in db.SitemapPermissionMaps on siteroleper.PermissionId equals permisionSite.Id
join permission in db.PermissionMasters on permisionSite.PermissionId equals permission.Id
join sitemap in db.SitemapMasters on siteroleper.SiteMapId equals sitemap.Id
where Roles.Contains(siteroleper.RoleId) && sitemap.IsVisible == true && sitemap.SitemapTypeID == SiteMapTypeId
select new SitePermissionsDTO()
{
// Id = siteroleper.Id,
SiteMapId = siteroleper.SiteMapId,
// SiteName = sitemap.Name,
PermissionId = permisionSite.PermissionId,
PermissionName = permission.Name
}).Distinct().DefaultIfEmpty();
return(sitePermissionList);
}
public bool UpdateUserRole(UserRolesDTO role)
{
UserRole oldRole = operationalDataContext.UserRoles.Where(r => r.UserRoleId == role.RoleId).FirstOrDefault();
if (oldRole != null)
{
oldRole.UserRoleName = role.RoleName;
oldRole.UserRoleDescriptionAr = role.RoleDescriptionAr;
oldRole.UserRoleDescriptionEn = role.RoleDescriptionEn;
operationalDataContext.RoleFeatures.RemoveRange(oldRole.RoleFeatures);
foreach (FeaturesDTO feature in role.RoleFeatures)
{
oldRole.RoleFeatures.Add(new RoleFeature
{
FeatureId = feature.FeatureId,
RoleId = oldRole.UserRoleId
});
}
return(operationalDataContext.SaveChanges() > 0);
}
else
{
return(AddUserRole(role));
}
}
public IHttpActionResult GetUserRoles()
{
List <UserRolesDTO> dto = new List <UserRolesDTO>();
var roles = this.AppRoleManager.Roles.ToList();
var users = this.AppUserManager.Users.ToList();
try
{
if (users != null)
{
foreach (var usr in users)
{
var usess = this.AppUserManager.FindById(usr.Id).Roles;
foreach (var ssdd in usess)
{
var rolename = this.AppRoleManager.FindById(ssdd.RoleId);
UserRolesDTO res = new UserRolesDTO();
res.Username = usr.UserName;
res.RoleName = rolename.Name;
dto.Add(res);
}
}
}
}
catch (Exception ex)
{
}
return(Ok(dto));
}
public async Task <IActionResult> AddNewRolePost(UserRolesDTO userRolesDTO)
{
await _usersController.AddNewRole(userRolesDTO);
var model = await _userRepo.GetUsers();
return(View("UsersList", model));
}
public void DeleteUserRolesServices(UserRolesDTO entity)
{
var userRoles = userRolesRepository.GetAll().Where(r => r.UserRoleId == entity.UserRoleId).FirstOrDefault();
userRoles.UserRole = entity.UserRole;
userRolesRepository.Delete(userRoles);
}
public ActionResult CreateAccount(UserVM model)
{
//Check model state
if (!ModelState.IsValid)
{
return(View("CreateAccount", model));
}
//Check if passwords match
if (!model.Password.Equals(model.ConfirmPassword))
{
ModelState.AddModelError("", "Passwords do not match.");
return(View("CreateAccount", model));
}
using (db DB = new db())
{
//check if username is unique
if (DB.Users.Any(x => x.UserName.Equals(model.UserName)))
{
ModelState.AddModelError("", "Username " + model.UserName + " is already taken.");
model.UserName = "";
return(View("CreateAccount", model));
}
//Create userDTO
UsersDTO userDTO = new UsersDTO()
{
FirstName = model.FirstName,
LastName = model.LastName,
EmailAddress = model.EmailAddress,
UserName = model.UserName,
Password = model.Password
};
//Add the DTO
DB.Users.Add(userDTO);
//Save
DB.SaveChanges();
//Add to userRolesDTO
int id = userDTO.Id;
UserRolesDTO UserRolesDTO = new UserRolesDTO()
{
UserId = id,
RoleId = 2
};
DB.UserRoles.Add(UserRolesDTO);
DB.SaveChanges();
}
//Create tempdata message
TempData["SM"] = "Registrated successfully.";
//Redirect
return(Redirect("~/account/login"));
}
public UserRoleEditFm(Utils.Operation operation, UserRolesDTO userRole)
{
InitializeComponent();
this.operation = operation;
userRoleBS.DataSource = Item = userRole;
roleNameTBox.DataBindings.Add("EditValue", userRoleBS, "RoleName");
}
public void AddNewUserRolesServices(UserRolesDTO entity)
{
UserRoles userRoles = new UserRoles
{
UserRole = entity.UserRole
};
userRolesRepository.Add(userRoles);
}
public UserRoleResponse AssignRole(UserRoleMapDTO userRoles, ApiContext apiContext)
{
_context = (MICAUMContext)DbManager.GetContext(apiContext.ProductType, apiContext.ServerType);
var roledata = _context.AspNetUserRoles.FirstOrDefault(x => x.UserId == userRoles.UserId);
UserRolesDTO roleDTO = new UserRolesDTO();
if (userRoles.RoleId != null)
{
if (roledata == null)
{
for (int i = 0; i < userRoles.RoleId.Length; i++)
{
roleDTO.UserId = userRoles.UserId;
roleDTO.RoleId = userRoles.RoleId[i];
AspNetUserRoles _usersRole = _mapper.Map <AspNetUserRoles>(roleDTO);
_context.AspNetUserRoles.Add(_usersRole);
// _context.SaveChanges();
}
}
else
{
var role = _context.AspNetUserRoles.Where(a => a.UserId == userRoles.UserId);
foreach (var item in role)
{
_context.AspNetUserRoles.Remove(item);
}
for (int i = 0; i < userRoles.RoleId.Length; i++)
{
roleDTO.UserId = userRoles.UserId;
roleDTO.RoleId = userRoles.RoleId[i];
AspNetUserRoles _usersRole = _mapper.Map <AspNetUserRoles>(roleDTO);
_context.AspNetUserRoles.Add(_usersRole);
// _context.SaveChanges();
}
}
var user = _context.TblUserDetails.SingleOrDefault(x => x.UserId == userRoles.UserId);
if (string.IsNullOrEmpty(user.RoleId))
{
user.RoleId = userRoles.RoleId[0].ToString();
}
_context.SaveChanges();
//return userRoles;
return(new UserRoleResponse {
Status = BusinessStatus.Created, role = userRoles, ResponseMessage = $"Assigned {userRoles.RoleId} Role successfully! "
});
}
else
{
return(new UserRoleResponse {
Status = BusinessStatus.Error, role = userRoles, ResponseMessage = $"Please select the Role to assign "
});
}
}
public IHttpActionResult GetPermissionofUserByRole(UserRolesDTO UserRoles)
{
var result = _PermissionMasterService.GetPermissionByUserAndRole(UserRoles);
if (result.ToList().Count <= 0)
{
return(NotFound());
}
return(Ok(result));
}
public ActionResult CreateAccount(UserVM model)
{
//proveriti stanje modela
if (!ModelState.IsValid)
{
return(View("CreateAccount", model));
}
//proveriti da li se slazu passwordi
if (!model.Password.Equals(model.ConfirmPassword))
{
ModelState.AddModelError("", "Password and Confirm Password doesn't match!");
return(View("CreateAccount", model));
}
using (ShoppingCartDB db = new ShoppingCartDB())
{
//proveriti da li je username unikatan
if (db.Users.Any(x => x.Username.Equals(model.Username)))
{
ModelState.AddModelError("", "Username is taken");
model.Username = "";
return(View("CreateAccount", model));
}
//napraviti userDTO
UserDTO dto = new UserDTO()
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Username = model.Username,
Password = model.Password
};
//dodati dto
db.Users.Add(dto);
//sacuvati
db.SaveChanges();
//dodati u UserRolesDTO
int id = dto.Id;
UserRolesDTO userRolesDTO = new UserRolesDTO()
{
UserId = id,
RoleID = 2
};
db.UserRoles.Add(userRolesDTO);
db.SaveChanges();
}
//napraviti temp poruku
TempData["SM"] = "You succesfully registrated!";
//redirektovati
return(Redirect("~/account/login"));
}
public ActionResult CreateAccount(UserVM model)
{
if (!ModelState.IsValid)
{
return(View("CreateAccount", model));
}
if (!model.Password.Equals(model.ConfirmPassword))
{
ModelState.AddModelError("", "Password do not match.");
return(View("CreateAccount", model));
}
using (CartDbContext db = new CartDbContext())
{
if (db.Users.Any(u => u.UserName.Equals(model.UserName)))
{
ModelState.AddModelError("", "Username " + model.UserName + " is already exist.");
model.UserName = "";
return(View("CreateAccount", model));
}
UserDTO userDTO = new UserDTO()
{
FirstName = model.FirstName,
LastName = model.LastName,
EmailAddress = model.EmailAddress,
UserName = model.UserName,
Password = model.Password
};
db.Users.Add(userDTO);
db.SaveChanges();
int id = userDTO.Id;
UserRolesDTO userRoleDTO = new UserRolesDTO()
{
UserId = id,
RoleId = 2
};
db.UserRoles.Add(userRoleDTO);
db.SaveChanges();
}
TempData["SM"] = "Your acccount has been created and you can login";
return(Redirect("~/account/login"));
}
public static UserRole ToUserRoles(this UserRolesDTO input)
{
if (input == null)
{
return(null);
}
return(new UserRole()
{
UserRoleDescriptionAr = input.RoleDescriptionAr,
UserRoleDescriptionEn = input.RoleDescriptionEn,
UserRoleId = input.RoleId,
UserRoleName = input.RoleName,
//RoleFeatures = input.RoleFeatures.ToList().ToFeatures();
});
}
public async Task <UserRolesDTO> GetRolesAsync(string userId)
{
var entity = await _userManager.FindByIdAsync(userId);
if (entity == null)
{
throw new ArgumentException("User not exists");
}
var claims = await _userManager.GetClaimsAsync(entity);
var givenName = claims.FirstOrDefault(x => x.Type == JwtRegisteredClaimNames.GivenName)?.Value;
var familyName = claims.FirstOrDefault(x => x.Type == JwtRegisteredClaimNames.FamilyName)?.Value;
var result = new UserRolesDTO
{
UserName = entity.UserName,
Name = $"{familyName}{givenName}",
Email = entity.Email,
Groups = new List <GroupRoleDTO>()
};
var roles = await _dbContext.Roles.ToListAsync();
var dict = await _dbContext.UserRoles.Where(x => x.UserId == userId)
.ToDictionaryAsync(x => x.RoleId, x => x);
var groups = roles.GroupBy(x => x.Type);
foreach (var group in groups)
{
var dto = new GroupRoleDTO {
Roles = new List <GrantRoleDTO>(), Type = group.Key
};
foreach (var permission in group)
{
dto.Roles.Add(new GrantRoleDTO
{
Name = permission.Name, Id = permission.Id, InRole = dict.ContainsKey(permission.Id)
});
}
result.Groups.Add(dto);
}
return(result);
}
public List <UserRolesDTO> GetUserRolesList()
{
try
{
List <UserRolesDTO> outputList = new List <UserRolesDTO>();
UserRolesDTO role = null;
var lst = operationalDataContext.UserRoles.ToList();
foreach (UserRole item in lst)
{
role = new UserRolesDTO();
role.RoleId = item.UserRoleId;
role.RoleName = item.UserRoleName;
role.RoleDescriptionAr = item.UserRoleDescriptionAr;
role.RoleDescriptionEn = item.UserRoleDescriptionEn;
role.RoleFeatures = new List <FeaturesDTO>();
foreach (RoleFeature feature in item.RoleFeatures)
{
FeaturesDTO dto = new FeaturesDTO();
Feature f = operationalDataContext.Features.Where(x => x.FeatureId == feature.FeatureId).FirstOrDefault();
if (f != null)
{
dto.FeatureId = f.FeatureId;
dto.PageId = f.PageId.Value;
dto.FeatureNameAr = f.FeatureNameAr;
dto.FeatureNameEn = f.FeatureNameEn;
role.RoleFeatures.Add(dto);
}
}
outputList.Add(role);
}
return(outputList);
}
catch (Exception ex)
{
}
return(null);
}
/// <summary>
/// gets the logged in user's detail from database and
/// returns ExpandedUserDTO objExpandedUserDTO from database.
/// </summary>
/// <param name="paramUserName"></param>
/// <returns>ExpandedUserDTO objExpandedUserDTO</returns>
/// <includesource>yes</includesource>
#region private ExpandedUserDTO GetUser(string paramUserName)
private ExpandedUserDTO GetUser(string paramUserName)
{
ExpandedUserDTO objExpandedUserDTO = new ExpandedUserDTO();
var result = UserManager.FindByName(paramUserName);
List <UserRolesDTO> roles = new List <UserRolesDTO>();
var roleslist = UserManager.FindByName(paramUserName).Roles.ToList();
foreach (IdentityUserRole rs in roleslist)
{ //find role name
string rolename = (db.Roles.Where(r => r.Id == rs.RoleId).Single().Name);
UserRolesDTO userRoleDTO = new UserRolesDTO();
userRoleDTO.RoleName = rolename;
//userRoleDTO.UserName = paramUserName;
roles.Add(userRoleDTO);
}
// If we could not find the user, throw an exception
if (result == null)
{
throw new Exception("Could not find the User");
}
objExpandedUserDTO.Companyname = result.Companyname;
objExpandedUserDTO.Forename = result.Forename;
objExpandedUserDTO.Surname = result.Surname;
objExpandedUserDTO.Street = result.Street;
objExpandedUserDTO.Town = result.Town;
objExpandedUserDTO.Postcode = result.Postcode;
objExpandedUserDTO.PhoneNumber = result.PhoneNumber;
objExpandedUserDTO.UserName = result.UserName;
objExpandedUserDTO.Email = result.Email;
objExpandedUserDTO.LockoutEndDateUtc = result.LockoutEndDateUtc;
objExpandedUserDTO.LockoutEnabled = result.LockoutEnabled;
objExpandedUserDTO.AccessFailedCount = result.AccessFailedCount;
objExpandedUserDTO.BacsApproved = result.BacsApproved;
objExpandedUserDTO.Roles = roles;
return(objExpandedUserDTO);
}
public bool AddUserRole(UserRolesDTO role)
{
UserRole userRole = new UserRole();
userRole.UserRoleName = role.RoleName;
userRole.UserRoleDescriptionAr = role.RoleDescriptionAr;
userRole.UserRoleDescriptionEn = role.RoleDescriptionEn;
userRole = operationalDataContext.UserRoles.Add(userRole);
foreach (FeaturesDTO feature in role.RoleFeatures)
{
var roleFeature = new RoleFeature
{
FeatureId = feature.FeatureId,
RoleId = userRole.UserRoleId
};
operationalDataContext.RoleFeatures.Add(roleFeature);
}
return(operationalDataContext.SaveChanges() > 0);
}
public bool DeleteUserRole(UserRolesDTO role)
{
try
{
UserRole oldRole = operationalDataContext.UserRoles.Where(r => r.UserRoleId == role.RoleId).FirstOrDefault();
if (oldRole != null)
{
operationalDataContext.RoleFeatures.RemoveRange(oldRole.RoleFeatures);
operationalDataContext.UserRoles.Remove(oldRole);
operationalDataContext.SaveChanges();
return(true);
}
return(false);
}
catch
{
return(false);
}
}
public UserRolesDTO GetUserRoleById(int roleId)
{
var item = operationalDataContext.UserRoles.Where(x => x.UserRoleId == roleId).FirstOrDefault();
if (item == null)
{
return(null);
}
UserRolesDTO role = new UserRolesDTO();
role.RoleId = item.UserRoleId;
role.RoleName = item.UserRoleName;
role.RoleDescriptionAr = item.UserRoleDescriptionAr;
role.RoleDescriptionEn = item.UserRoleDescriptionEn;
role.RoleFeatures = new List <FeaturesDTO>();
foreach (RoleFeature feature in item.RoleFeatures)
{
FeaturesDTO dto = new FeaturesDTO();
Feature f = operationalDataContext.Features.Where(x => x.FeatureId == feature.FeatureId).FirstOrDefault();
if (f != null)
{
dto.FeatureId = f.FeatureId;
dto.PageId = f.PageId.Value;
dto.FeatureNameAr = f.FeatureNameAr;
dto.FeatureNameEn = f.FeatureNameEn;
role.RoleFeatures.Add(dto);
}
}
return(role);
}
public void UserRoleUpdate(UserRolesDTO urdto)
{
var eRole = UserRoles.GetAll().SingleOrDefault(c => c.RoleId == urdto.RoleId);
UserRoles.Update(mapper.Map <UserRolesDTO, UserRoles>(urdto, eRole));
}
public int UserRoleCreate(UserRolesDTO urdto)
{
var newRole = UserRoles.Create(mapper.Map <UserRoles>(urdto));
return(newRole.RoleId);
}
public ActionResult CreateAccount(AccountVM model)
{
if (!ModelState.IsValid)
{
return(View("CreateAccount", model));
}
string filename = Path.GetFileNameWithoutExtension(model.ImageFile.FileName);
string extension = Path.GetExtension(model.ImageFile.FileName);
filename = filename + DateTime.Now.ToString("yymmssff") + extension;
model.ImagePath = "~/Image/" + filename;
filename = Path.Combine(Server.MapPath("~/Image/"), filename);
model.ImageFile.SaveAs(filename);
//Check if Password match
if (!model.Password.Equals(model.ConfirmPassword))
{
ModelState.AddModelError("", "Password Doesnot Match");
return(View("CreateAccount", model));
}
//Username is Unique
using (Db db = new Db())
{
if (db.Account.Any(x => x.UserName.Equals(model.UserName)))
{
ModelState.AddModelError("", "Username already exists ");
model.UserName = "";
return(View("CreateAccount", model));
}
//Create AccountDTO
AccountDTO accounts = new AccountDTO()
{
FirstName = model.FirstName,
LastName = model.LastName,
Age = model.Age,
Gender = model.Gender,
Email = model.Email,
UserName = model.UserName,
Password = model.Password,
ImagePath = model.ImagePath
};
//Add AccountDTO
db.Account.Add(accounts);
//SAve
ModelState.Clear();
db.SaveChanges();
//Role
int id = accounts.UserId;
UserRolesDTO userrolesdto = new UserRolesDTO()
{
UserId = id,
RolesId = 2
};
db.UserRoles.Add(userrolesdto);
db.SaveChanges();
}
//Tempdata
TempData["SM"] = "You are now Registered";
return(RedirectToAction("Login"));
}
private UserRolesDTO AddUpdateUserRoles(UserRolesDTO userRolesDTO)
{
string insertProcedure = "[CreateUserRoles]";
SqlCommand insertCommand = new SqlCommand(insertProcedure, connection);
insertCommand.CommandType = CommandType.StoredProcedure;
if (userRolesDTO.RoleId != 0)
{
insertCommand.Parameters.AddWithValue("@RoleId", userRolesDTO.RoleId);
}
else
{
insertCommand.Parameters.AddWithValue("@RoleId", 0);
}
if (!string.IsNullOrEmpty(userRolesDTO.RoleName))
{
insertCommand.Parameters.AddWithValue("@RoleName", userRolesDTO.RoleName);
}
else
{
insertCommand.Parameters.AddWithValue("@RoleName", 0);
}
if (!string.IsNullOrEmpty(userRolesDTO.Description))
{
insertCommand.Parameters.AddWithValue("@Description", userRolesDTO.Description);
}
else
{
insertCommand.Parameters.AddWithValue("@Description", 0);
}
if (userRolesDTO.IsActive)
{
insertCommand.Parameters.AddWithValue("@IsActive", userRolesDTO.IsActive);
}
else
{
insertCommand.Parameters.AddWithValue("@IsActive", 0);
}
if (userRolesDTO.UserId != 0)
{
insertCommand.Parameters.AddWithValue("@UserId ", userRolesDTO.UserId);
}
else
{
insertCommand.Parameters.AddWithValue("@UserId", 0);
}
if (userRolesDTO.Type != 0)
{
insertCommand.Parameters.AddWithValue("@Type", userRolesDTO.Type);
}
else
{
insertCommand.Parameters.AddWithValue("@Type", 0);
}
insertCommand.Parameters.Add("@RoleIdOut", System.Data.SqlDbType.Int);
insertCommand.Parameters["@RoleIdOut"].Direction = ParameterDirection.Output;
insertCommand.Parameters.Add("@ReturnValue", System.Data.SqlDbType.Int);
insertCommand.Parameters["@ReturnValue"].Direction = ParameterDirection.Output;
try
{
int count = 0;
connection.Open();
insertCommand.ExecuteNonQuery();
if (insertCommand.Parameters["@ReturnValue"].Value != DBNull.Value)
{
count = System.Convert.ToInt32(insertCommand.Parameters["@ReturnValue"].Value);
userRolesDTO.val = count;
}
if (count != 0 && userRolesDTO.RoleId == 0)
{
userRolesDTO.RoleId = System.Convert.ToInt32(insertCommand.Parameters["@RoleIdOut"].Value);
}
return(userRolesDTO);
}
catch (Exception ex)
{
log.logErrorMessage("UserRolesData.AddUpdateUserRoles");
log.logErrorMessage(ex.StackTrace);
return(userRolesDTO);
}
finally
{
connection.Close();
}
}
public List <dynamic> SaveUserRoleData(UserRoles userRoles)
{
List <dynamic> objDynamic = new List <dynamic>();
UserRolesDTO UserRolesDTO = new UserRolesDTO();
try
{
var Data = JsonConvert.DeserializeObject <List <UserRolesDTO> >(userRoles.RoleDesc);
for (int i = 0; i < Data.Count; i++)
{
UserRolesDTO = Data[i];
if (!String.IsNullOrEmpty(UserRolesDTO.RoleName))
{
if (UserRolesDTO.RoleId == 0)
{
UserRolesDTO.Type = 1;
}
else
{
UserRolesDTO.Type = 2;
UserRolesDTO.IsActive = true;
}
if (UserRolesDTO.Ischange == 1)
{
if (!string.IsNullOrEmpty(UserID))
{
UserRolesDTO.UserId = Convert.ToInt64(UserID);
}
if (UserRolesDTO.IsDelete == true)
{
UserRolesDTO.Type = 3;
UserRolesDTO.IsActive = false;
}
AddUpdateUserRoles(UserRolesDTO);
if (UserRolesDTO.val == -99)
{
break;
}
}
}
else
{
UserRolesDTO.val = -98;
}
}
objDynamic.Add(UserRolesDTO.val);
objDynamic.Add(GetUseRolerData());
}
catch (Exception ex)
{
}
return(objDynamic);
}
