public ActionResult Create(JobPositionViewModel model)
{
if (ModelState.IsValid)
{
Responses responses = (JobPositionRepo.Update(model));
if (responses.Success)
{
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { success = false, message = "Error msg" }, JsonRequestBehavior.AllowGet));
}
}
return(Json(new { success = false, message = "Invalid" }, JsonRequestBehavior.AllowGet));
}
public IActionResult New(JobPositionOrigin origin)
{
OperationResultVo serviceResult = jobPositionAppService.GenerateNew(CurrentUserId, origin);
if (serviceResult.Success)
{
OperationResultVo <JobPositionViewModel> castResult = serviceResult as OperationResultVo <JobPositionViewModel>;
JobPositionViewModel model = castResult.Value;
return(PartialView("_CreateEdit", model));
}
else
{
return(PartialView("_CreateEdit", new JobPositionViewModel()));
}
}
public static Responses Update(JobPositionViewModel entity)
{
Responses result = new Responses();
try
{
using (var db = new PayrollContext())
{
if (entity.Id != 0)
{
JobPosition jobposition = db.JobPosition.Where(o => o.Id == entity.Id).FirstOrDefault();
if (jobposition != null)
{
jobposition.Code = entity.Code;
jobposition.DepartmentId = entity.DepartmentId;
jobposition.Description = entity.Description;
jobposition.IsActivated = entity.IsActivated;
jobposition.ModifyBy = "Azam";
jobposition.ModifyDate = DateTime.Now;
db.SaveChanges();
}
}
else
{
JobPosition jobposition = new JobPosition();
jobposition.Code = entity.Code;
jobposition.DepartmentId = entity.DepartmentId;
jobposition.Description = entity.Description;
jobposition.IsActivated = entity.IsActivated;
jobposition.CreateBy = "Azam";
jobposition.CreateDate = DateTime.Now;
db.JobPosition.Add(jobposition);
db.SaveChanges();
}
}
}
catch (Exception ex)
{
result.Message = ex.Message;
result.Success = false;
}
return(result);
}
/// <summary>
/// Update job position
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel> UpdateJobPositionAsync(JobPositionViewModel model)
{
if (model == null)
{
return(new InvalidParametersResultModel());
}
var jobPosition = await _context.JobPositions.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == model.Id);
if (jobPosition == null)
{
return(new NotFoundResultModel());
}
jobPosition.Name = model.Name;
_context.JobPositions.Update(jobPosition);
return(await _context.PushAsync());
}
public IActionResult Edit(Guid jobPositionId)
{
OperationResultVo serviceResult = jobPositionAppService.GetById(CurrentUserId, jobPositionId);
if (serviceResult.Success)
{
OperationResultVo <JobPositionViewModel> castResult = serviceResult as OperationResultVo <JobPositionViewModel>;
JobPositionViewModel model = castResult.Value;
model.ClosingDateText = model.ClosingDate.HasValue ? model.ClosingDate.Value.ToShortDateString() : string.Empty;
SetLocalization(model, true);
return(PartialView("_CreateEdit", model));
}
else
{
return(null);
}
}
public OperationResultVo <Guid> Save(Guid currentUserId, JobPositionViewModel viewModel)
{
int pointsEarned = 0;
try
{
JobPosition model;
JobPosition existing = jobPositionDomainService.GetById(viewModel.Id);
if (existing != null)
{
model = mapper.Map(viewModel, existing);
}
else
{
model = mapper.Map <JobPosition>(viewModel);
}
if (viewModel.Id == Guid.Empty)
{
jobPositionDomainService.Add(model);
viewModel.Id = model.Id;
pointsEarned += gamificationDomainService.ProcessAction(currentUserId, PlatformAction.JobPositionPost);
}
else
{
jobPositionDomainService.Update(model);
}
unitOfWork.Commit();
viewModel.Id = model.Id;
return(new OperationResultVo <Guid>(model.Id, pointsEarned));
}
catch (Exception ex)
{
return(new OperationResultVo <Guid>(ex.Message));
}
}
/// <summary>
/// Add new job position
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > AddNewJobPositionAsync(JobPositionViewModel model)
{
if (model == null)
{
return(new InvalidParametersResultModel <Guid>());
}
var newJobPosition = new JobPosition
{
Name = model.Name
};
await _context.JobPositions.AddAsync(newJobPosition);
var result = await _context.PushAsync();
return(new ResultModel <Guid>
{
Result = newJobPosition.Id, IsSuccess = result.IsSuccess, Errors = result.Errors
});
}
public async Task <IActionResult> JobPosition(string id)
{
IRequestCultureFeature requestCulture = this.Request
.HttpContext
.Features
.Get <IRequestCultureFeature>();
var culture = requestCulture
.RequestCulture
.Culture
.Name;
JobPositionViewModel viewModel = await this.careerService.GetJobById(id, culture);
var model = new JobPositionBaseModel
{
JobPositionViewModel = viewModel,
JobCandidateInputModel = new JobCandidateInputModel(),
};
return(this.View(model));
}
public IActionResult Save(JobPositionViewModel vm)
{
try
{
bool isNew = vm.Id == Guid.Empty;
vm.UserId = CurrentUserId;
if (!string.IsNullOrWhiteSpace(vm.ClosingDateText))
{
vm.ClosingDate = DateTime.Parse(vm.ClosingDateText);
}
OperationResultVo <Guid> saveResult = jobPositionAppService.Save(CurrentUserId, vm);
if (saveResult.Success)
{
GenerateFeedPost(vm);
string url = Url.Action("Details", "JobPosition", new { area = "Work", id = vm.Id, pointsEarned = saveResult.PointsEarned });
if (isNew)
{
NotificationSender.SendTeamNotificationAsync("New Job Position posted!");
}
return(Json(new OperationResultRedirectVo(saveResult, url)));
}
else
{
return(Json(new OperationResultVo(false)));
}
}
catch (Exception ex)
{
return(Json(new OperationResultVo(ex.Message)));
}
}
private void SetLocalization(JobPositionViewModel item, bool editing)
{
if (item != null)
{
if (item.Remote || string.IsNullOrWhiteSpace(item.Location))
{
item.Location = SharedLocalizer["Planet Earth"];
}
DisplayAttribute displayWorkType = item.WorkType.GetAttributeOfType <DisplayAttribute>();
Microsoft.Extensions.Localization.LocalizedString localizedWorkType = SharedLocalizer[displayWorkType != null ? displayWorkType.Name : item.WorkType.ToString()];
item.Title = SharedLocalizer["{0} at {1}", localizedWorkType, item.Location];
DisplayAttribute displayStatus = item.Status.GetAttributeOfType <DisplayAttribute>();
item.StatusLocalized = SharedLocalizer[displayStatus != null ? displayStatus.Name : item.WorkType.ToString()];
if ((item.Id != Guid.Empty && !editing && (!string.IsNullOrWhiteSpace(item.CompanyName) && item.CompanyName.Equals(JobPositionBenefit.NotInformed.ToDisplayName()))) || string.IsNullOrWhiteSpace(item.CompanyName))
{
item.CompanyName = SharedLocalizer[JobPositionBenefit.NotInformed.ToDisplayName()];
}
}
}
private void FormatJobPositionPostForTheFeed(UserContentViewModel item)
{
JobPositionViewModel obj = JsonConvert.DeserializeObject<JobPositionViewModel>(item.Content);
SupportedLanguage language = SupportedLanguage.English;
if (obj.Remote)
{
obj.Location = SharedLocalizer["remote"];
}
if (obj.Language != 0)
{
language = obj.Language;
}
string postTemplate = ContentHelper.FormatUrlContentToShow(item.UserContentType);
string translatedText = SharedLocalizer["A new job position for {0}({1}) is open for applications.", SharedLocalizer[obj.WorkType.ToDisplayName()], obj.Location].ToString();
item.Content = String.Format(postTemplate, translatedText, SharedLocalizer[obj.WorkType.ToDisplayName()], obj.Location);
item.Url = Url.Action("Details", "JobPosition", new { area = "Work", id = obj.Id.ToString() });
item.Language = language;
}
public static JobPositionViewModel GetById(int id)
{
JobPositionViewModel result = new JobPositionViewModel();
using (var db = new PayrollContext())
{
result = (from d in db.JobPosition
join dep in db.Department on
d.DepartmentId equals dep.Id
where d.Id == id
select new JobPositionViewModel
{
Id = d.Id,
Code = d.Code,
DepartmentId = d.DepartmentId,
DepartmentCode = dep.Code,
DepartmentName = dep.Description,
Description = d.Description,
IsActivated = d.IsActivated
}).FirstOrDefault();
}
return(result);
}
// PUT api/<controller>/5
public Responses Put(int id, [FromBody] JobPositionViewModel entity)
{
entity.Id = id;
return(JobPositionRepo.Update(entity));
}
// POST api/<controller>
public Responses Post([FromBody] JobPositionViewModel entity)
{
return(JobPositionRepo.Update(entity));
}
private static void SetPermissions(Guid currentUserId, JobPositionViewModel vm)
{
SetBasePermissions(currentUserId, vm);
vm.Permissions.CanConnect = !string.IsNullOrWhiteSpace(vm.Url) || (vm.Status == JobPositionStatus.OpenForApplication && (!vm.ClosingDate.HasValue || DateTime.Today <= vm.ClosingDate.Value.Date));
}
private void SetLocalization(JobPositionViewModel item)
{
SetLocalization(item, false);
}
public OperationResultVo <JobPositionViewModel> GetById(Guid currentUserId, Guid id)
{
try
{
JobPosition model = jobPositionDomainService.GetById(id);
if (model == null)
{
return(new OperationResultVo <JobPositionViewModel>("JobPosition not found!"));
}
JobPositionViewModel vm = mapper.Map <JobPositionViewModel>(model);
foreach (JobApplicantViewModel applicant in vm.Applicants)
{
UserProfile profile = GetCachedProfileByUserId(applicant.UserId);
if (profile != null)
{
applicant.JobPositionId = id;
applicant.Name = profile.Name;
applicant.Location = profile.Location;
applicant.ProfileImageUrl = UrlFormatter.ProfileImage(applicant.UserId, 84);
applicant.CoverImageUrl = UrlFormatter.ProfileCoverImage(applicant.UserId, profile.Id, null, profile.HasCoverImage, 300);
}
}
vm.Applicants = vm.Applicants.OrderByDescending(x => x.Score).ToList();
vm.CurrentUserApplied = model.Applicants.Any(x => x.UserId == currentUserId);
vm.ApplicantCount = model.Applicants.Count;
if (vm.Benefits == null)
{
vm.Benefits = new List <JobPositionBenefitVo>();
}
List <JobPositionBenefit> allBenefits = Enum.GetValues(typeof(JobPositionBenefit)).Cast <JobPositionBenefit>().Where(x => x != JobPositionBenefit.NotInformed).ToList();
foreach (JobPositionBenefit benefit in allBenefits)
{
if (!vm.Benefits.Any(x => x.Benefit == benefit))
{
vm.Benefits.Add(new JobPositionBenefitVo {
Benefit = benefit, Available = false
});
}
}
SetPermissions(currentUserId, vm);
if (string.IsNullOrWhiteSpace(vm.Reference))
{
vm.Reference = vm.Id.ToString();
}
return(new OperationResultVo <JobPositionViewModel>(vm));
}
catch (Exception ex)
{
return(new OperationResultVo <JobPositionViewModel>(ex.Message));
}
}
