public async Task <ExecutionResponse <MetricModel> > CreateMetric(UpdateMetricModel model)
{
var oldMetric = _metricQueryRepo.GetAll().FirstOrDefault(x => x.Name.Trim().ToLower() == model.Name.Trim().ToLower() && x.CompanyId == CurrentCompanyId);
if (oldMetric != null)
{
throw new Exception("Metric already exists");
}
//save metric info
var metric = new Metric
{
Name = model.Name,
DepartmentId = model.DepartmentId,
Description = model.Description,
CompanyId = CurrentCompanyId,
CreateById = _httpContext.GetCurrentSSOUserId()
};
await _metricCommandRepo.InsertAsync(metric);
await _metricCommandRepo.SaveChangesAsync();
return(new ExecutionResponse <MetricModel>
{
ResponseCode = ResponseCode.Ok,
ResponseData = _mapper.Map <MetricModel>(metric)
});
}
public async Task <ExecutionResponse <VenueModel> > CreateVenue(VenueModel model)
{
var oldVenue = _venueQueryRepo.GetAll().FirstOrDefault(x => x.Name.Trim().ToLower() == model.Name.Trim().ToLower());
if (oldVenue != null)
{
throw new Exception("Venue already exists");
}
//save venue info
var venue = new Venue
{
Name = model.Name,
CompanyId = CurrentCompanyId,
Description = model.Description,
CreateById = _httpContext.GetCurrentSSOUserId()
};
await _venueCommandRepo.InsertAsync(venue);
await _venueCommandRepo.SaveChangesAsync();
return(new ExecutionResponse <VenueModel>
{
ResponseCode = ResponseCode.Ok,
ResponseData = _mapper.Map <VenueModel>(venue)
});
}
public async Task <ExecutionResponse <InterviewSessionModel> > CreateInterviewSession(InterviewSessionModel model)
{
//save interviewSession info
var interviewSession = new InterviewSession
{
StartTime = model.StartTime,
EndTime = model.EndTime,
Subject = model.Subject,
VenueId = model.VenueId,
RecruiterId = _httpContext.GetCurrentUserId(),
CompanyId = CurrentCompanyId,
JobRoleId = model.JobRoleId,
CreateById = _httpContext.GetCurrentSSOUserId()
};
await _interviewSessionCommandRepo.InsertAsync(interviewSession);
await _interviewSessionCommandRepo.SaveChangesAsync();
return(new ExecutionResponse <InterviewSessionModel>
{
ResponseCode = ResponseCode.Ok,
ResponseData = _mapper.Map <InterviewSessionModel>(interviewSession)
});
}
public async Task <ExecutionResponse <CompanyModel> > CreateCompany(CompanyModel model)
{
var oldCompany = _companyQueryRepo.GetAll().FirstOrDefault(x => x.Name.Trim().ToLower() == model.Name.Trim().ToLower());
if (oldCompany != null)
{
throw new Exception("Company already exists");
}
//save company info
var company = new Company
{
Name = model.Name,
Code = model.Code,
CreateById = _httpContext.GetCurrentSSOUserId()
};
await _companyCommandRepo.InsertAsync(company);
await _companyCommandRepo.SaveChangesAsync();
return(new ExecutionResponse <CompanyModel>
{
ResponseCode = ResponseCode.Ok,
ResponseData = _mapper.Map <CompanyModel>(company)
});
}
public async Task <ExecutionResponse <DepartmentModel> > CreateDepartment(DepartmentModel model)
{
var oldDepartment = _departmentQueryRepo.GetAll().FirstOrDefault(x => x.Name.Trim().ToLower() == model.Name.Trim().ToLower());
if (oldDepartment != null)
{
throw new Exception("Department already exists");
}
//save department info
var department = new Department
{
Name = model.Name,
CompanyId = CurrentCompanyId,
Description = model.Description,
CreateById = _httpContext.GetCurrentSSOUserId()
};
await _departmentCommandRepo.InsertAsync(department);
await _departmentCommandRepo.SaveChangesAsync();
return(new ExecutionResponse <DepartmentModel>
{
ResponseCode = ResponseCode.Ok,
ResponseData = _mapper.Map <DepartmentModel>(department)
});
}
public async Task <ExecutionResponse <object> > SetInterviewInterviewers(long[] interviewerIds, long interviewSessionId)
{
try
{
var interviewSession = _interviewSessionQueryRepo.GetAll().FirstOrDefault(x => x.Id == interviewSessionId && x.CompanyId == CurrentCompanyId);
if (interviewSession == null)
{
throw new Exception("Interview session does not exist");
}
var interviewInterviewers = _interviewSessionInterviewerQueryRepo.GetAll().Where(x => x.InterviewSessionId == interviewSessionId);
//to add
foreach (var id in interviewerIds)
{
if (!interviewInterviewers.Select(x => x.Id).ToArray().Contains(id))
{
await _interviewSessionInterviewerCommandRepo.InsertAsync(new InterviewSessionInterviewer { InterviewSessionId = interviewSessionId, InterviewerId = id, CreateById = _httpContext.GetCurrentSSOUserId() });
}
}
//to remove
foreach (var item in interviewInterviewers.ToList())
{
if (!interviewerIds.Contains(item.Id))
{
await _interviewSessionInterviewerCommandRepo.DeleteAsync(item);
}
}
await _interviewSessionInterviewerCommandRepo.SaveChangesAsync();
return(new ExecutionResponse <object>
{
ResponseData = true,
ResponseCode = ResponseCode.Ok
});
}
catch (Exception ex)
{
Log.Error(ex);
return(new ExecutionResponse <object>
{
ResponseData = false,
ResponseCode = ResponseCode.ServerException,
Message = ex.Message
});
}
}
public async Task <ActionResult> Create(PermissionViewModel permissionVm)
{
try
{
CreateViewBagParams();
if (ModelState.IsValid)
{
var permission = new Permission()
{
Name = permissionVm.PermissionName,
Code = permissionVm.PermissionCode,
CreatedBy = User.Identity.GetUserId <Int64>()
};
await _permissionCommand.InsertAsync(permission);
await _permissionCommand.SaveChangesAsync();
_activityRepo.CreateActivityLog(string.Format("Created Portal permission with Name:{0}", permission.Name), this.GetContollerName(), this.GetContollerName(), User.Identity.GetUserId <Int64>(), permission);
TempData["MESSAGE"] = "Permission " + permissionVm.PermissionName + " was successfully created";
ModelState.Clear();
return(Json(new { success = true }));
}
else
{
StringBuilder errorMsg = new StringBuilder();
foreach (var modelError in ModelState.Values.SelectMany(modelState => modelState.Errors))
{
errorMsg.AppendLine(modelError.ErrorMessage);
ModelState.AddModelError(string.Empty, modelError.ErrorMessage);
}
ViewBag.ErrMsg = errorMsg.ToString();
return(PartialView("_PartialAddEdit", permissionVm));
}
}
catch (Exception exp)
{
_log.Error(exp);
return(View("Error"));
}
}
public async Task CreateActivityLogAsync(string descriptn, string moduleName, string moduleAction, Int64 userid, object record)
{
try
{
ActivityLog alog = new ActivityLog
{
ModuleName = moduleName,
ModuleAction = moduleAction,
UserId = userid,
Description = descriptn,
Record = record != null?JsonConvert.SerializeObject(record) : "N/A"
};
await _activityLogRepositoryCommand.InsertAsync(alog);
await _activityLogRepositoryCommand.SaveChangesAsync();
}
catch (Exception ex)
{
_log.Error(ex);
}
}
public async Task <ActionResult> Create(PermissionViewModel permissionVm)
{
long currentUserId = GetCurrentUserId();
try
{
CreateViewBagParams();
if (ModelState.IsValid)
{
var permission = _mapper.Map <PermissionViewModel, Permission>(permissionVm);
permission.CreatedBy = currentUserId;
await _permissionCommand.InsertAsync(permission);
await _permissionCommand.SaveChangesAsync();
_activityRepo.CreateActivityLog(string.Format("Created Portal permission with Name:{0}", permission.Name), this.ControllerContext.ActionDescriptor.ControllerName, this.ControllerContext.ActionDescriptor.ActionName, currentUserId, permission);
TempData["MESSAGE"] = "Permission " + permissionVm.PermissionName + " was successfully created";
ModelState.Clear();
return(Json(new { success = true }));
}
else
{
StringBuilder errorMsg = new StringBuilder();
foreach (var modelError in ModelState.Values.SelectMany(modelState => modelState.Errors))
{
errorMsg.AppendLine(modelError.ErrorMessage);
ModelState.AddModelError(string.Empty, modelError.ErrorMessage);
}
ViewBag.ErrMsg = errorMsg.ToString();
return(PartialView("_PartialAddEdit", permissionVm));
}
}
catch (Exception exp)
{
_log.LogError(exp.Message);
return(View("Error"));
}
}
public async Task <ExecutionResponse <JobRoleModel> > CreateJobRole(UpdateJobRoleModel model)
{
var oldJobRole = _jobRoleQueryRepo.GetAll().FirstOrDefault(x => x.Name.Trim().ToLower() == model.Name.Trim().ToLower() && x.Department.CompanyId == CurrentCompanyId);
if (oldJobRole != null)
{
throw new Exception("Job Role already exists");
}
if (!_departmentQueryRepo.GetAll().Any(d => d.Id == model.DepartmentId && d.CompanyId == CurrentCompanyId))
{
return new ExecutionResponse <JobRoleModel>
{
ResponseCode = ResponseCode.NotFound,
Message = "Department does not exist"
}
}
;
//save jobRole info
var jobRole = new JobRole
{
Name = model.Name,
DepartmentId = model.DepartmentId,
Description = model.Description,
CreateById = _httpContext.GetCurrentSSOUserId()
};
await _jobRoleCommandRepo.InsertAsync(jobRole);
await _jobRoleCommandRepo.SaveChangesAsync();
return(new ExecutionResponse <JobRoleModel>
{
ResponseCode = ResponseCode.Ok,
ResponseData = _mapper.Map <JobRoleModel>(jobRole)
});
}
public async Task <ExecutionResponse <UserModel> > AddUserRole(UserRoleModel model)
{
var role = _roleQueryRepo.GetAll().FirstOrDefault(f => f.Id == model.RoleId);
if (role == null)
{
return(new ExecutionResponse <UserModel>
{
ResponseCode = ResponseCode.NotFound,
Message = "Role does not exist"
});
}
if (CurrentCompanyId == 0 && role.RoleName != "CompanyAdmin")
{
throw new Exception($"You cannot add role '{role.RoleName}' to a user");
}
var user = _userQueryRepo.GetAll().FirstOrDefault(f => f.Id == model.UserId);
if (user == null || (CurrentCompanyId != 0 && user.CompanyId != CurrentCompanyId))
{
return(new ExecutionResponse <UserModel>
{
ResponseCode = ResponseCode.NotFound,
Message = "User does not exist"
});
}
if (!user.UserRoles.Any(u => u.RoleId == role.Id))
{
var result = await _ssoService.AddRemoveClaims(new UserClaimModel { Claims = new List <SSOClaim> {
new SSOClaim("role", role.RoleName)
}, UserId = user.SSOUserId }, ClaimAction.Add);
if (result.ResponseCode == ResponseCode.Ok)
{
await _userRoleCommandRepo.InsertAsync(new UserRole { RoleId = role.Id, UserId = user.Id });
await _userRoleCommandRepo.SaveChangesAsync();
return(await GetUser(model.UserId));
}
else
{
return(new ExecutionResponse <UserModel>
{
ResponseCode = ResponseCode.ServerException,
Message = result.Message
});
}
}
else
{
return(new ExecutionResponse <UserModel>
{
ResponseCode = ResponseCode.ServerException,
Message = "User is already attached to specified role"
});
}
}
public async Task <ExecutionResponse <UserModel> > CreateUser(CreateUserModel model)
{
if (_userQueryRepo.GetAll().Any(u => u.Email.Trim().ToLower() == model.Email.Trim().ToLower()))
{
return new ExecutionResponse <UserModel>
{
ResponseCode = ResponseCode.ServerException,
Message = "User with specified email already exists"
}
}
;
var role = _roleQueryRepo.GetAll().FirstOrDefault(x => x.Id == model.RoleId);
if (role == null)
{
throw new Exception("Invalid Role");
}
if (CurrentCompanyId == 0 && role.RoleName != "CompanyAdmin")
{
throw new Exception($"You cannot create a user with role '{role.RoleName}'");
}
var company = _companyQueryRepo.GetAll().FirstOrDefault(x => x.Id == model.CompanyId);
if (company == null)
{
throw new Exception("Company does not exist");
}
var registerReponse = await _ssoService.Register(new SSOUserDto
{
Claims = new List <SSOClaim> {
new SSOClaim("role", GetSSORole(role.RoleName)),
new SSOClaim("role", role.RoleName)
},
ConfirmEmail = false,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = string.IsNullOrEmpty(model.PhoneNumber) ? "08111111111" : model.PhoneNumber,
UserName = model.UserName,
Password = model.Password
});
if (registerReponse.ResponseCode != ResponseCode.Ok)
{
return new ExecutionResponse <UserModel>
{
ResponseCode = ResponseCode.ServerException,
Message = registerReponse.Message
}
}
;
//user registered on sso
//trigger reset password
//save user info
var user = new User
{
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = string.IsNullOrEmpty(model.PhoneNumber) ? "08111111111" : model.PhoneNumber,
UserName = model.UserName,
CompanyId = CurrentCompanyId == 0 ? model.CompanyId : CurrentCompanyId,
EmailConfirmed = false,
CreateById = CurrentUserId,
SSOUserId = registerReponse.ResponseData.UserId
};
await _userCommandRepo.InsertAsync(user);
await _userCommandRepo.SaveChangesAsync();
//assign role to user
await _userRoleCommandRepo.InsertAsync(new UserRole { RoleId = role.Id, UserId = user.Id, CreateById = CurrentUserId });
await _userRoleCommandRepo.SaveChangesAsync();
//send email confirmation mail
_emailService.EmailConfirmation(registerReponse.ResponseData.EmailConfirmationToken, model.Email, $"{model.FirstName} {model.LastName}", registerReponse.ResponseData.UserId);
return(new ExecutionResponse <UserModel>
{
ResponseCode = ResponseCode.Ok,
ResponseData = _mapper.Map <UserModel>(user)
});
}
public async Task <ActionResult> Create(EventViewModel eventVm)
{
string filename = string.Empty;
string fileName = string.Empty;
eventVm.Artists = _utility.GetAllArtists();
try
{
CreateViewBagParams();
if (ModelState.IsValid)
{
//checking if organizer name does not exist b4
var eventnameExist = _EventQuery.GetAllList(m => m.EventName.ToLower().Trim() == eventVm.EventName.ToLower().Trim()).ToList();
if (eventnameExist.Any())
{
ModelState.AddModelError("", "Event name already exist");
return(PartialView("_PartialAddEdit", eventVm));
}
var eventmodel = new Event()
{
EventName = eventVm.EventName,
EventDescription = eventVm.EventDescription,
Venue = eventVm.Venue,
ArtistId = eventVm.ArtistId,
City = eventVm.City,
Country = eventVm.Country,
StartDate = ExtentionUtility.ConvertDateValue(eventVm.StartDate),
EndDate = ExtentionUtility.ConvertDateValue(eventVm.EndDate),
CreatedBy = GetCurrentUserID()
};
//Save Event
await _EventCommand.InsertAsync(eventmodel);
await _EventCommand.SaveChangesAsync();
_activityRepo.CreateActivityLog(string.Format("User ID: {0} Created event with event Name:{0}", GetCurrentUserID(), eventmodel.EventName), this.GetContollerName(), this.GetActionName(), GetCurrentUserID(), eventmodel);
TempData["MESSAGE"] = "Event " + eventmodel.EventName + " was successfully created";
ModelState.Clear();
return(Json(new { success = true }));
}
else
{
StringBuilder errorMsg = new StringBuilder();
var errorModel =
from x in ModelState.Keys
where ModelState[x].Errors.Count > 0
select new
{
key = x,
errors = ModelState[x].Errors.
Select(y => y.ErrorMessage).
ToArray()
};
foreach (var item in errorModel)
{
errorMsg.AppendLine(string.Format("Error Key: {0} Error Message: {1}", item.key, string.Join(",", item.errors)));
ModelState.AddModelError(item.key, string.Join(",", item.errors));
}
ViewBag.ErrMsg = errorMsg.ToString();
return(PartialView("_PartialAddEdit", eventVm));
}
}
catch (Exception exp)
{
_log.Error(exp);
return(View("Error"));
}
}
