public IActionResult CreateResume(ResumeViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
//get Logged In User Id
var userId = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
//check for file extension to be pdf or docx file
var permittedTypes = new[] { ".docx", ".pdf" };
var extensionType = Path.GetExtension(viewModel.ResumePdf.FileName)?.ToLowerInvariant();
if (string.IsNullOrEmpty(extensionType) || !permittedTypes.Contains(extensionType))
{
ModelState.AddModelError(string.Empty, "Only Pdf files are permitted");
}
ResumeService.CreateResume(viewModel, userId);
}
catch (Exception e)
{
//log errors with the logger
_logger.LogError(e.Message);
_logger.LogError(e.StackTrace);
ModelState.AddModelError(string.Empty, e.Message);
}
return(RedirectToAction("Index", "UserDashboard"));
}
ModelState.AddModelError(string.Empty, "Invalid details");
return(View("Index"));
}
// GET: ResumeViewModels/Details/5
public async Task <IActionResult> Details(int id)
{
var resume = new ResumeViewModel();
resume.Contact = await _context.Person.FirstOrDefaultAsync(p => p.PersonId == id);
resume.Schools = await _context.Education.Where(e => e.PersonId == id).ToListAsync();
resume.Job = await _context.Jobs.Where(j => j.PersonId == id).ToListAsync();
return(View(resume));
//ResumeViewModel resumeViewModel = new ResumeViewModel();
//resumeViewModel.Contact = await _context.Person.SingleOrDefaultAsync(m => m.PersonId == id);
//resumeViewModel.Job = await _context.Jobs.Where(j => j.PersonId == id)
// .AsNoTracking()
// .ToListAsync();
//resumeViewModel.Schools = await _context.Education.Where(e => e.PersonId == id)
// .AsNoTracking()
// .ToListAsync();
//if (resumeViewModel == null)
//{
// return NotFound();
//}
//return View(resumeViewModel);
}
public async Task <IActionResult> Edit(int id, [Bind("Id")] ResumeViewModel resumeViewModel)
{
if (id != resumeViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(resumeViewModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ResumeViewModelExists(resumeViewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(resumeViewModel));
}
public ActionResult Create(ResumeViewModel viewModel)
{
try
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var resume = new ResumeDTO
{
ResumeName = viewModel.ResumeName,
ResumeDescript = viewModel.ResumeDescript,
EmployeeId = viewModel.EmployeeId,
CategoryId = viewModel.CategoryId
};
resumeService.AddResume(resume);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
}
return(View(viewModel));
}
public IActionResult AddResume(ResumeViewModel model)
{
if (model == null)
{
return(BadRequest());
}
Resume resume = new Resume();
resume.FullName = model.FullName;
resume.City = model.City;
resume.AbleToRelocate = model.AbleToRelocate;
resume.DesiredPosition = model.DesiredPosition;
resume.HasExperience = model.HasExperience;
resume.DesiredSalary = model.DesiredSalary;
resume.HighEducations = model.HighEducations;
resume.Skills = model.Skills;
resume.Description = model.Description;
resume.LanguagesKnowlegde = model.LanguagesKnowledge;
resume.LearnedCourses = model.LearnedCourses;
resume.OwnerId = db.Users.FirstOrDefault(x => x.Login == model.OwnerLogin).Id;
resume.CreatedTime = DateTime.Now;
db.Resumes.Add(resume);
db.SaveChanges();
return(Ok());
}
// GET: Resume
public ActionResult ViewUserProfile(string idTemplate, string idProfile)
{
ResumeViewModel vm = new ResumeViewModel();
using (var db = new GvGenEntities())
{
var template = db.TTemplates.FirstOrDefault(p => p.Name == idTemplate);
if (template == null)
{
//TODO:Redirect 404
}
var profile = db.TProfiles.FirstOrDefault(p => p.IdProfile == new Guid(idProfile));
if (profile == null)
{
//TODO:Redirect 404
}
else
{
vm.Template = template;
vm.PersonalInformation = profile;
vm.Educations = db.TEducations.Where(ed => ed.IdProfile == profile.Id).ToList();
vm.WorkExps = db.TWorkExperiences.Where(w => w.IdProfile == profile.Id).ToList();
vm.Skills = db.TSkills.Where(s => s.IdProfile == profile.Id).ToList();
vm.References = db.TReferences.Where(r => r.IdProfile == profile.Id).ToList();
}
}
return(View(vm));
}
public async Task <IActionResult> EditResume(ResumeViewModel viewModel)
{
FilledResume filledResume = new FilledResume();
filledResume.UserInfo = viewModel.UserInfo;
filledResume.StreamId = _streamService.GetStreamByFullName(viewModel.StreamFullName).Id;
filledResume.ResumeId = viewModel.ResumeId;
filledResume.Summary = viewModel.Summary;
filledResume.Skills = viewModel.Skills;
filledResume.ForeignLanguages = viewModel.ForeignLanguages;
filledResume.Educations = viewModel.Educations;
filledResume.Courses = viewModel.Courses;
filledResume.Certificates = viewModel.Certificates;
filledResume.Exams = viewModel.Exams;
WorkExperience[] workExperiences = new WorkExperience[viewModel.WorkExperiences.Length];
for (int i = 0; i < viewModel.WorkExperiences.Count(); i++)
{
workExperiences[i] = viewModel.WorkExperiences[i].ToWorkExperience();
}
filledResume.WorkExperiences = workExperiences;
filledResume.Portfolios = viewModel.Portfolios;
filledResume.MilitaryStatus = viewModel.MilitaryStatus;
filledResume.AdditionalInfo = viewModel.AdditionalInfo;
filledResume.Recommendations = viewModel.Recommendations;
await _editResumeService.SaveFullResumeAsync(filledResume);
return(RedirectToAction(nameof(ResumeReviewController.Index), "ResumeReview", new { resumeId = viewModel.ResumeId }));
}
public ActionResult Edit(int id, ResumeViewModel viewModel)
{
try
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <ResumeViewModel, ResumeDTO>()).CreateMapper();
var resumeView = mapper.Map(viewModel, resumeService.GetResume(id));
// ViewBag.CategoryId = new SelectList(categoryService.GetCategories(), "CategoryId", "CategoryName", resumeView.CategoryId);
// ViewBag.EmployeeId = new SelectList(employeeService.GetEmployees(), "EmployeeId", "EmployeeLastName", resumeView.EmployeeId);
resumeService.UpdateResume(resumeView);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
}
return(View(viewModel));
}
public void Create(ResumeViewModel command)
{
var newresume = new Resume(command.Priority, command.FromYear, command.ToYear, command.Title, command.Description);
_irepository.Create(newresume);
_irepository.SaveChanges();
}
public void Edit(ResumeViewModel command)
{
var selecteditem = _irepository.GetByID(command.Id);
selecteditem.Edit(command.Priority, command.FromYear, command.ToYear, command.Title, command.Description);
_irepository.SaveChanges();
}
//
// GET: /رزومه/
public ActionResult مشاهده(long HumanId)
{
ViewBag.HumanID = HumanId;
ResumeViewModel Resume = new ResumeViewModel();
using (KARYABDBEntities db = new KARYABDBEntities())
{
HUMAN human = db.HUMen.FirstOrDefault(q => q.ID == HumanId);
Resume.NAME = human.NAME;
Resume.GENDER = human.GENDER;
Resume.USAGE = human.USAGE;
//Resume.Image = db.IMAGES.FirstOrDefault(q => q.HUMANID == HumanId).IMAGE1;
List <long> ExperiencesIds = db.OWNERSEXPERIENCES.Where(q => q.EXPERIENCEOWNERID == HumanId).Select(q => q.EXPERIENCEID).ToList();
Resume.Experiences = db.EXPERIENCES.Where(q => ExperiencesIds.Contains(q.ID)).ToList();
List <long> EducationIds = db.OWNERSEDUCATIONS.Where(q => q.EDUCATIONOWNERID == HumanId).Select(q => q.EDUCATIONID).ToList();
Resume.Educations = db.EDUCATONS.Where(q => EducationIds.Contains(q.ID)).ToList();
List <long> SkillIlds = db.OWNERSSKILLS.Where(q => q.SKILLOWNERID == HumanId).Select(q => q.SKILLID).ToList();
Resume.Skills = db.SKILLS.Where(q => SkillIlds.Contains(q.ID)).ToList();
List <long> AdressIds = db.OWNERSADRESES.Where(q => q.ADRESSOWNERID == HumanId).Select(q => q.ADRESSID).ToList();
Resume.Adresses = db.ADRESSES.Where(q => AdressIds.Contains(q.ID)).ToList();
List <long> PhoneIds = db.OWNERSPHOES.Where(q => q.PHONEOWNERID == HumanId).Select(q => q.PHONENUMBERID).ToList();
Resume.Phones = db.PHONES.Where(q => PhoneIds.Contains(q.ID)).ToList();
List <long> CellPhoneIds = db.OWNERSCELLPHONES.Where(q => q.CELLPHONEOWNERID == HumanId).Select(q => q.CELLPHONEID).ToList();
Resume.Cellphones = db.CELLPHONES.Where(q => CellPhoneIds.Contains(q.ID)).ToList();
List <long> EmailIds = db.OWNERSMAILS.Where(q => q.MAILOWNERID == HumanId).Select(q => q.MAILADRESSID).ToList();
Resume.Emails = db.MAILADRESSES.Where(q => EmailIds.Contains(q.ID)).ToList();
}
return(View(Resume));
}
public ActionResult Create(int id)
{
var aidi = id;
string uid = User.Identity.GetUserId();
bool flag = false;
List <ResumeModel> list = _context.resumes.Where(x => x.User_Id == uid)
.Where(x => x.Offer_Id == id).ToList();
if (list.Count > 0)
{
flag = true;
}
if (flag == false)
{
ResumeViewModel resume = new ResumeViewModel()
{
User_Id = User.Identity.GetUserId(),
Offer_Id = id,
};
return(View(resume));
}
else
{
return(RedirectToAction("MoreInfo", "Offer", new { id = aidi }));
}
}
public ActionResult Resume()
{
ResumeViewModel model = new ResumeViewModel();
model.Path = "/Resources/RESUME.pdf";
model.MimeType = "application/pdf";
return(View(model));
}
public ActionResult Create()
{
ViewBag.CategoryId = new SelectList(categoryService.GetCategories(), "CategoryId", "CategoryName");
ViewBag.EmployeeId = new SelectList(employeeService.GetEmployees(), "EmployeeId", "EmployeeLastName", "EmployeeFirstName");
var newResume = new ResumeViewModel();
return(View(newResume));
}
public ActionResult Index()
{
var urlsAndStats = UserProfileService.ReadProfileStatisticsAndSocialLinks(User.UserId);
var viewModel = new ResumeViewModel()
{
ProfileStatisticsAndSocialLinks = urlsAndStats,
};
return(View(viewModel));
}
public async Task <IActionResult> Create([Bind("Id")] ResumeViewModel resumeViewModel)
{
if (ModelState.IsValid)
{
_context.Add(resumeViewModel);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(resumeViewModel));
}
public IActionResult Index()
{
ResumeViewModel viewModel = new ResumeViewModel();
viewModel.SkillItems = _context.Skills.ToList();
viewModel.EducationItems = _context.Educations.ToList();
viewModel.ExperienceItems = _context.Experiences.ToList();
return(View("Resume", viewModel));
//return View();
}
public async Task <IActionResult> SaveRecomendationsAsync(ResumeViewModel vm)
{
if (ModelState.IsValid)
{
Resume resume = _resumeService.GetResumeById(vm.ResumeId);
resume.CurrentStep = vm.CurrentResumeStep;
await _recommendationResumeService.SaveRecommendationsAndUpdateResumeAsync(resume, vm.Recommendations);
}
return(RedirectToAction("Index", vm));
}
public async Task <IActionResult> SaveLanguageAsync(ResumeViewModel vm)
{
if (ModelState.IsValid)
{
Resume resume = _resumeService.GetResumeById(vm.ResumeId);
resume.CurrentStep = vm.CurrentResumeStep;
await _foreingLanguageResumeService.SaveForeignLanguagesAndUpdateResumeAsync(resume, vm.ForeignLanguages);
}
return(RedirectToAction("Index", vm));
}
// GET: Resume/Details/5
public async Task <ActionResult> Details(int id)
{
var resume = new ResumeViewModel();
resume.Contact = await _context.People.FirstOrDefaultAsync(p => p.ID == id);
resume.Educations = await _context.Education.Where(e => e.PeopleId == id).ToListAsync();
resume.Jobs = await _context.Job.Where(j => j.PeopleId == id).ToListAsync();
return(View(resume));
}
public ActionResult Resume()
{
ResumeViewModel VM = new ResumeViewModel
{
Bio = db.Bio.FirstOrDefault(),
Skills = db.Skills.OrderByDescending(a => a.Id).ToList(),
AcademicBackgrounds = db.AcademicBackGround.OrderByDescending(a => a.Id).ToList(),
ProffesionalExperiences = db.ProffesionalExperience.OrderByDescending(a => a.Id).ToList()
};
return(View(VM));
}
// GET: Resume
public ActionResult Index()
{
var vm = new ResumeViewModel();
vm.Intro = "My current objective is to secure a software engineering internship to gain industry experience. " +
"I am eager to learn from others while working on a team.";
vm.Skills = _context.Skills.ToList();
vm.Experiences = _context.Experiences.ToList();
vm.Educations = _context.Educations.ToList();
return(View(vm));
}
public ActionResult Delete(int id, ResumeViewModel viewModel)
{
try
{
resumeService.DeleteResume(id);
return(RedirectToAction("Index"));
}
catch
{
ModelState.AddModelError("", "An error has occured. This Employee was not deleted.");
}
return(View(viewModel));
}
public IHttpActionResult GetResume(int id)
{
ResumeViewModel resumeView = Mapper.Map <ResumeDTO, ResumeViewModel>(resumeService.GetResumeById(id));
if (resumeView == null)
{
return(Content(System.Net.HttpStatusCode.NoContent, "Not found resume"));
}
else
{
return(Ok(resumeView));
}
}
public IActionResult CrtResume(ResumeViewModel model)
{
if (ModelState.IsValid)
{
Resume res = new Resume()
{
Post = model.Post, Education = model.Education, Experience = model.Experience, AdditionalInformation = model.AdditionalInformation
};
db.Employees.Include(e => e.Resumes).FirstOrDefault(e => e.Login == User.Identity.Name).Resumes.Add(res);
db.SaveChanges();
return(RedirectToAction("EmployeeAccount"));
}
return(View(model));
}
public IActionResult EditResume(ResumeViewModel resumeViewModel)
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
if (!this.ModelState.IsValid)
{
return(View(resumeViewModel));
}
var resume = mapper.MapTo <Resume>(resumeViewModel);
resumeService.SaveResume(resume);
return(this.ViewResume());
}
public IActionResult Index()
{
ResumeViewModel model = new ResumeViewModel(Database, CultureInfo.CurrentUICulture);
if (model.Resume == null)
{
return(NotFound());
}
model.Resume.Content = model.Resume.Content
.Replace("%WEBSITE%", $"{Request.Scheme}://{Request.Host}/", true, CultureInfo.InvariantCulture)
.Replace("%PHONE_NUMBER%", Database.Links.Find("phone")?.Username, true, CultureInfo.InvariantCulture)
.Replace("%EMAIL%", Database.Links.Find("outlook")?.Username, true, CultureInfo.InvariantCulture);
return(View(model));
}
public async Task <IActionResult> SaveSkillsAsync(ResumeViewModel vm)
{
var userInfo = _userInfo;
var currentStudent = _studentService.GetCurrentStudentByUserInfo(userInfo.Id);
if (ModelState.IsValid)
{
Resume resume = _resumeService.GetResumeById(vm.ResumeId);
resume.CurrentStep = vm.CurrentResumeStep;
await _skillResumeService.SaveSkillsAndUpdateResumeAsync(resume, currentStudent.Id, vm.Skills);
}
return(RedirectToAction("Index", vm));
}
public async Task <IActionResult> SaveStreamAsync(ResumeViewModel vm)
{
if (ModelState.IsValid)
{
UserInfo userInfo = _userInfo;
Student currentStudent = _studentService.GetCurrentStudentByUserInfo(userInfo.Id);
Resume resume = _resumeService.GetResumeById(vm.ResumeId);
resume.CurrentStep = vm.CurrentResumeStep;
int streamId = _streamService.GetStreamByFullName(vm.StreamFullName).Id;
await _streamResumeService.SaveStreamAndUpdateResumeAsync(resume, currentStudent.Id, streamId);
}
return(RedirectToAction("Index", vm));
}
public async Task <IActionResult> SaveUserInfoAsync(ResumeViewModel vm)
{
var user = _userInfo;
vm.UserInfo.Email = user.Email;
if (ModelState.IsValid)
{
Resume resume = _resumeService.GetResumeById(vm.ResumeId);
resume.CurrentStep = vm.CurrentResumeStep;
await _userInfoResumeService.SaveUserInfoAndUpdateResumeAsync(resume, vm.UserInfo);
}
return(RedirectToAction("Index", vm));
}
