public async Task<ActionResult> Edit(int id) {
var factory = await GetFactory();
var typesApi = factory.GetExperienceTypesApi();
var api = factory.GetExperiencesApi();
var types = await typesApi.GetExperienceTypes();
var experience = await api.GetExperience(id);
var model = new ExperienceViewModel {
Title = experience.Title,
Organisation = experience.Organisation,
Description = experience.Description,
Start = experience.Start,
End = experience.End,
ContactName = experience.ContactName,
ContactEmail = experience.ContactEmail,
ContactPhone = experience.ContactPhone,
//TypeID = experience.TypeID,
Types = types.Select(t => new SelectListItem {
Text = t.Name,
Value = t.ID.ToString()
})
};
return View(model);
}
public async Task <IActionResult> EditExperience(ExperienceViewModel model)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var specialist = await _specialistService.FindAsync(userId);
if (ModelState.IsValid)
{
var experience = new Experience()
{
Id = model.Id,
CompanyName = model.CompanyName,
Position = model.Position,
StartDate = model.StartDate,
EndDate = model.EndDate,
SpecialistId = specialist.Id
};
var result = await _specialistService.UpdateExperience(experience);
if (result != null)
{
TempData["Status"] = "Note has been edited";
return(RedirectToAction("EducationsAndExperience"));
}
}
return(View(model));
}
/// <summary>
/// View an experience as an instructor
/// NOTE: Instructor must have acccess to the experience AND the experience must have instructorViewable = true
/// </summary>
/// <param name="id">Experience Id</param>
/// <param name="notificationId">Notification to show along with experience</param>
/// <returns></returns>
public ActionResult ViewExperience(Guid id, Guid?notificationId)
{
var experience =
RepositoryFactory.ExperienceRepository.Queryable.SingleOrDefault(x => x.Id == id &&
x.Instructors.Any(i => i.Identifier == CurrentUser.Identity.Name));
if (experience == null)
{
return(new HttpNotFoundResult());
}
if (experience.InstructorViewable == false)
{
return(new HttpUnauthorizedResult());
}
var notification = notificationId.HasValue == false
? null
: RepositoryFactory.FeedbackRequestRepository.Queryable.SingleOrDefault(
x =>
x.Id == notificationId.Value &&
x.Instructor.Identifier == CurrentUser.Identity.Name);
var model = new ExperienceViewModel
{
Experience = experience,
Notification = notification,
SupportingWorks = experience.SupportingWorks.ToList(),
ExperienceOutcomes = experience.ExperienceOutcomes.ToList()
};
return(View(model));
}
public async Task <bool> AddNewExperience(ExperienceViewModel experience)
{
try
{
var userId = _userAppContext.CurrentUserId;
User userProfile = await _userRepository.GetByIdAsync(userId);
if (userProfile == null)
{
return(false);
}
var newExperience = new UserExperience
{
Id = ObjectId.GenerateNewId().ToString()
};
UpdateExperienceFromView(experience, newExperience);
userProfile.Experience.Add(newExperience);
await _userRepository.Update(userProfile);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <bool> UpdateExperience(ExperienceViewModel experience)
{
try
{
var userId = _userAppContext.CurrentUserId;
User userProfile = await _userRepository.GetByIdAsync(userId);
if (userProfile == null)
{
return(false);
}
var orginalExperience = userProfile.Experience.SingleOrDefault(x => x.Id == experience.Id);
if (orginalExperience == null)
{
return(false);
}
UpdateExperienceFromView(experience, orginalExperience);
await _userRepository.Update(userProfile);
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Details of each Experience.
/// </summary>
/// <param name="id">Employee Id</param>
/// <returns>Experience, Details view</returns>
// GET: Experience/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Experience experience = db.Experiences.Find(id);
if (experience == null)
{
return(HttpNotFound());
}
var model = new ExperienceViewModel
{
Id = experience.ExperienceId,
EmployeeName = experience.Employee.FullName,
EmploymentPlace = experience.EmploymentPlace,
EmploymentType = experience.EmploymentType,
StartDate = experience.StartDate,
EndDate = experience.EndDate,
Description = experience.Description,
OrgnizationType = experience.OrgnizationType,
};
return(View(model));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Experience experience = db.Experiences.Find(id);
if (experience == null)
{
return(HttpNotFound());
}
ExperienceViewModel model = new ExperienceViewModel
{
Id = experience.ExperienceId,
EmploymentPlace = experience.EmploymentPlace,
EmploymentType = experience.EmploymentType,
StartDate = experience.StartDate,
EndDate = experience.EndDate,
Description = experience.Description,
OrgnizationType = experience.OrgnizationType,
};
ViewBag.EmployeeId = new SelectList(db.Employees, "Id", "FullName");
return(View(model));
}
public ActionResult Create(ExperienceViewModel model)
{
if (ModelState.IsValid)
{
var experience = new Experience
{
ExperienceId = model.Id,
EmploymentPlace = model.EmploymentPlace,
EmploymentType = model.EmploymentType,
StartDate = model.StartDate,
EndDate = model.EndDate,
Description = model.Description,
OrgnizationType = model.OrgnizationType,
EmployeeId = model.EmployeeId,
};
db.Experiences.Add(experience);
db.SaveChanges();
return(RedirectToAction("Index"));
}
var list = db.Employees.ToList().Select(e => new { e.Id, e.FullName });
ViewBag.EmployeeId = new SelectList(list, "Id", "FullName");
ViewBag.ExperienceId = new SelectList(db.Experiences, "ExperienceId", "OrgnizationType");
return(View(model));
}
public async Task <ActionResult> deleteUpdateExperience([FromBody] ExperienceViewModel experience)
{
experience.IsDeleted = true;
var id = await _profileService.AddUpdateExperience(experience);
return(Json(new { Id = id }));
}
private IHttpActionResult InsertExperience(ExperienceViewModel ExperienceVM)
{
try
{
if (!IsExperienceAvailble(ExperienceVM))
{
return(Json(new { Result = "ERROR", Message = "Experience Name already exists" }));
}
Experience ExperienceADD = new Experience
{
EmployeeID = ExperienceVM.EmployeeID,
CompanyID = ExperienceVM.CompanyID,
FromDate = ExperienceVM.FromDate,
ToDate = ExperienceVM.ToDate,
IsActive = ExperienceVM.IsActive,
ExperienceTechnologys = GetExperienceTechnologies(ExperienceVM.Technologies, ExperienceVM.ID)
};
_repository.ExperienceRepository.Add(ExperienceADD);
if (_repository.ExperienceRepository.Save((WindowsPrincipal)User) > 0)
{
var Record = _repository.ExperienceRepository.GetField(ExperienceADD.ID);
return(Json(new { Result = "OK", Record = ExperienceADD }));
}
else
{
return(Json(new { Result = "ERROR", Message = Errors.MessageError }));
}
}
catch (Exception ex)
{
return(Json(new { Result = "ERROR", Message = Errors.Write(ex) }));
}
}
public async Task <IActionResult> UpdateExperience([FromBody] ExperienceViewModel experience)
{
try
{
if (ModelState.IsValid)
{
String id = "";
String talentId = String.IsNullOrWhiteSpace(id) ? _userAppContext.CurrentUserId : id;
var result = _userRepository.GetByIdAsync(talentId).Result;
if (experience.Id != null)
{
var updateExperience = result.Experience.SingleOrDefault(x => x.Id == experience.Id);
{
updateExperience.Company = experience.Company;
updateExperience.Position = experience.Position;
updateExperience.Responsibilities = experience.Responsibilities;
updateExperience.Start = experience.Start;
updateExperience.End = experience.End;
}
await _userRepository.Update(result);
}
return(Json(new { Success = true }));
}
return(Json(new { Success = false }));
}
catch (Exception e)
{
return(Json(new { Success = false, e.Message }));
}
}
public async Task <IActionResult> DeleteExperience([FromBody] ExperienceViewModel experience)
{
//Your code here;
await _profileService.DeleteExperienceAsync(experience);
return(Json(new { Success = true }));
}
// GET: Users/Details/5
public ActionResult Details(string id)
{
try
{
if (id == null)
{
throw new Exception();
}
ApplicationUser applicationUser = db.Users.Find(id);
if (applicationUser.IsInRole("Candidate"))
{
Experience experience = db.Experiences.Where(e => e.CandidateId == id).FirstOrDefault();
ExperienceViewModel experienceModel = new ExperienceViewModel()
{
userId = id,
JobId = applicationUser.CandidateInterview.JobId,
addedSkills = db.CandidateSkills.Where(cs => cs.ExperienceId == experience.ExperienceId).Select(cs => cs.Skill).ToList(),
userEducation = db.Educations.Where(e => e.ExperienceId == experience.ExperienceId).ToList(),
addedPastJobs = db.PastJobs.Where(pj => pj.ExperienceId == experience.ExperienceId).ToList()
};
return(View("~/Views/Users/CandidateDetails.cshtml", experienceModel));
}
return(View(applicationUser));
}
catch (NullReferenceException)
{
ViewBag.exceptionMessage = "The user doesn't exist.";
}
catch (Exception)
{
ViewBag.exceptionMessage = "You can't access this page.";
}
return(View(error));
}
public ActionResult addExperience([FromBody] ExperienceViewModel experience)
{
try
{
if (ModelState.IsValid)
{
String id = "";
String talentId = String.IsNullOrWhiteSpace(id) ? _userAppContext.CurrentUserId : id;
var addExperience = new UserExperience
{
Id = ObjectId.GenerateNewId().ToString(),
Company = experience.Company,
Position = experience.Position,
Responsibilities = experience.Responsibilities,
Start = experience.Start,
End = experience.End
};
var result = _userRepository.GetByIdAsync(talentId).Result;
result.Experience.Add(addExperience);
_userRepository.Update(result);
return(Json(new { Success = true }));
}
return(Json(new { Success = false }));
}
catch (Exception e)
{
return(Json(new { Success = false, e.Message }));
}
}
public async Task <ActionResult> DeleteExperience([FromBody] ExperienceViewModel delete_experince_model, String id = "")
{
//Your code here;
String talentId = String.IsNullOrWhiteSpace(id) ? _userAppContext.CurrentUserId : id;
if (talentId != null)
{
User existingTalent = (await _userRepository.GetByIdAsync(talentId));
var newExperiences = new List <UserExperience>();
foreach (var item in existingTalent.Experience)
{
var delete_language = existingTalent.Languages.SingleOrDefault(x => x.Id == delete_experince_model.Id);
if (item.Id != delete_experince_model.Id)
{
newExperiences.Add(item);
}
}
existingTalent.Experience = newExperiences;
existingTalent.UpdatedBy = talentId;
existingTalent.UpdatedOn = DateTime.Now;
await _userRepository.Update(existingTalent);
User UpdateTalent = (await _userRepository.GetByIdAsync(talentId));
return(Json(new { success = true, data = existingTalent }));
}
return(Json(new { success = false }));
}
public async Task <IActionResult> DeleteExperience([FromBody] ExperienceViewModel experience)
{
try
{
var userId = _userAppContext.CurrentUserId;
var user = await _userRepository.GetByIdAsync(userId);
if (user != null)
{
var findExperienceItem = user.Experience.SingleOrDefault(x => x.Id == experience.Id);
if (findExperienceItem != null)
{
user.Experience.Remove(findExperienceItem);
await _userRepository.Update(user);
return(Json(new { Success = true }));
}
else
{
return(Json(new { Success = false, Message = "Can't find the language!" }));
}
}
else
{
return(Json(new { Success = false, Message = "Can't find the user!" }));
}
}
catch (Exception e)
{
return(Json(new { Message = "error" }));
}
}
public async Task <IActionResult> ExperienceAsync([FromRoute] Guid id)
{
string experiencesEndPoint = _apiUrls.Experiences + $"/{id}";
string experienceReviewsEndPoint = _apiUrls.Experiences + $"/{id}/" + _apiUrls.Reviews;
//string experienceRatingsEndPoint = _apiUrls.API + _apiUrls.Experiences + $"/{id}" + _apiUrls.Ratings;
ViewData["ExperienceId"] = RouteData.Values["id"].ToString();
//TODO:
//Insert Rating in controller
ExperienceViewModel viewModel = new ExperienceViewModel();
var responseExperience = await _oplevOgDelService.Client.GetAsync(experiencesEndPoint);
if (responseExperience.IsSuccessStatusCode)
{
viewModel.Experience = await responseExperience.Content.ReadAsAsync <ExperienceDto>();
}
var responseReviews = await _oplevOgDelService.Client.GetAsync(experienceReviewsEndPoint);
if (responseReviews.IsSuccessStatusCode)
{
viewModel.Reviews = await responseReviews.Content.ReadAsAsync <List <ReviewDto> >();
}
return(View(viewModel));
}
public async Task <string> AddUpdateExperience(ExperienceViewModel experience)
{
if (experience.Id != null && experience.Id != "") //update
{
var experienceInDb = await _userExperienceRepository.GetByIdAsync(experience.Id);
_mapper.Map(experience, experienceInDb);
await _userExperienceRepository.Update(experienceInDb);
var user = await _userRepository.GetByIdAsync(_userAppContext.CurrentUserId);
var userExperienceInDB = user.Experience.Single(ex => ex.Id == experience.Id);
_mapper.Map(experience, userExperienceInDB);
await _userRepository.Update(user);
return(experience.Id);
}
else //create
{
var newExperience = _mapper.Map <ExperienceViewModel, UserExperience>(experience);
await _userExperienceRepository.Add(newExperience);
var user = await _userRepository.GetByIdAsync(_userAppContext.CurrentUserId);
user.Experience.Add(newExperience);
await _userRepository.Update(user);
return(newExperience.Id);
}
}
// GET: Experience/Create/string
/// <summary>
/// Create a new experience object related to this resume
/// </summary>
/// <param name="resumeId"></param>
/// <returns></returns>
public ActionResult Create([FromQuery] string resumeId)
{
ExperienceViewModel model = new ExperienceViewModel();
model.ResumeId = resumeId;
return(View(model));
}
public async Task <IActionResult> Edit(int id)
{
User user = await _db.Users.Include(e => e.Experiences).FirstOrDefaultAsync(u => u.Id == _userManager.GetUserId(User));
Experience exp = user.Experiences.FirstOrDefault(l => l.ExperienceId == id);
if (exp != null)
{
ExperienceViewModel viewModel = new ExperienceViewModel
{
Id = exp.ExperienceId,
Title = exp.Title,
Link = exp.Link,
Description = exp.Description,
StartDate = exp.StartDate,
FinishDate = exp.FinishDate,
IsWork = exp.IsWork,
IsNow = exp.Now
};
return(View(viewModel));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> updateEXP([FromBody] ExperienceViewModel model)
{
//Your code here;
if (model != null)
{
var userId = _userAppContext.CurrentUserId;
UserExperience updatesmodel = new UserExperience()
{
Id = model.Id,
UserId = userId,
Company = model.Company,
Position = model.Position,
Start = model.Start,
End = model.End,
Responsibilities = model.Responsibilities,
};
await _userExperienceRepository.Update(updatesmodel);
return(Json(new { message = "user experience update is complete" }));
}
else
{
throw new NotImplementedException();
}
}
public async Task <IActionResult> Edit(ExperienceViewModel model)
{
if (ModelState.IsValid)
{
User user = await _db.Users.Include(e => e.Experiences).FirstOrDefaultAsync(u => u.Id == _userManager.GetUserId(User));
Experience exp = user.Experiences.FirstOrDefault(l => l.ExperienceId == model.Id);
if (exp != null)
{
exp.Title = model.Title;
exp.Link = model.Link;
exp.Description = model.Description;
exp.IsWork = model.IsWork;
exp.Now = model.IsNow;
exp.StartDate = model.StartDate;
exp.FinishDate = model.FinishDate;
}
_db.Users.Update(user);
await _db.SaveChangesAsync();
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> EditExperience(int id, ExperienceViewModel exp)
{
var experience = context.Experiences.First(exp => exp.Id == id);
experience.ExperiencePictures = context.ExperiencePictures.Where(pic => pic.ExperienceId == id).ToList();
experience.Name = exp.Experience.Name;
if (ModelState.IsValid)
{
if (Request.Form.Files.Count > 0)
{
IFormFile file = Request.Form.Files.FirstOrDefault();
using (var dataStream = new MemoryStream())
{
await file.CopyToAsync(dataStream);
var picture = new Picture()
{
Image = dataStream.ToArray()
};
experience.ExperiencePictures.Add(picture);
}
}
}
context.Update(experience);
await context.SaveChangesAsync();
return(RedirectToAction("EditExperience", new { id = experience.Id }));
}
protected void UpdateExperienceFromView(ExperienceViewModel model, UserExperience original)
{
original.Company = model.Company;
original.Position = model.Position;
original.Responsibilities = model.Responsibilities;
original.Start = model.Start;
original.End = model.End;
}
public JsonResult AddToCart(JsonVoucherItem itemUpdate)
{
ExperiencesViewModel storedModel = (ExperiencesViewModel)HttpContext.Session["experiences"];
ExperienceViewModel exp = storedModel.Experiences.Find(e => e.Code == itemUpdate.VoucherCode);
_cart.AddItem(exp, itemUpdate.Qty);
return(Json("OK"));
}
public ActionResult EditExperience(ExperienceViewModel experience)
{
if (ModelState.IsValid)
{
var isUpdated = UpdateExperience(User.Identity.GetUserId(), experience);
if (isUpdated)
{
return(Json(new { success = true }));
}
}
return(PartialView("_EditExperience", experience));
}
public IActionResult EditExperience(int id)
{
var experience = context.Experiences.FirstOrDefault(exp => exp.Id == id);
experience.ExperiencePictures = context.ExperiencePictures.Where(pic => pic.ExperienceId == id).ToList();
var expView = new ExperienceViewModel()
{
Experience = experience
};
return(View(expView));
}
public bool IsExperienceExists(ExperienceViewModel Experience)
{
try
{
bool IsOrder = _repository.ExperienceRepository.Any(cc => cc.ID == Experience.ID);
return(IsOrder);
}
catch (Exception)
{
return(false);
}
}
// Nik custom code
protected UserExperience ExperienceFromViewModel(ExperienceViewModel model)
{
return(new UserExperience
{
Id = model.Id,
UserId = _userAppContext.CurrentUserId,
Company = model.Company,
Position = model.Position,
Responsibilities = model.Responsibilities,
Start = model.Start,
End = model.End,
IsDeleted = false,
});
}
public bool IsExperienceAvailble(ExperienceViewModel ExperienceVM)
{
try
{
bool IsOrder;
IsOrder = !_repository.ExperienceRepository.Any(cc => cc.CompanyID == ExperienceVM.CompanyID && cc.EmployeeID == ExperienceVM.EmployeeID && cc.FromDate == ExperienceVM.FromDate && cc.ID != ExperienceVM.ID);
return(IsOrder);
}
catch (Exception)
{
return(true);
}
}
public async Task<ActionResult> Add() {
var factory = await GetFactory();
var api = factory.GetExperienceTypesApi();
var types = await api.GetExperienceTypes();
var model = new ExperienceViewModel() {
Types = types.Select(t => new SelectListItem {
Text = t.Name,
Value = t.ID.ToString()
})
};
return View(model);
}
public void RemoveItem(ExperienceViewModel experience, int quantity)
{
CartLine line = lineCollection
.Where(e => e.Experience.Code == experience.Code)
.FirstOrDefault();
if (quantity == 0)
{
lineCollection.RemoveAll(l => l.Experience.Code == experience.Code);
}
else
{
line.Quantity = quantity;
}
}
