public virtual async Task <Recruiter> GetRecruiterAsync(Recruiter recruiter) { return(await _recruiterRepository.GetByIdAsync(recruiter.Id)); }
private async void UpdateRecruiter(bool isCompanyChanged) { try { string dbPath_attributes = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "attributes.db3"); var db_attributes = new SQLiteConnection(dbPath_attributes); MyAttributes myAttributes = db_attributes.Get <MyAttributes>(1); int id_login = myAttributes.loginid; int id_recruiter = myAttributes.typeid; string username = updateEmail.Text.Split('@')[0]; string domain = updateEmail.Text.Split('@')[1]; string provider = domain.Split('.')[0]; string extension = domain.Split('.')[1]; // Update Login User updateLogin = new User(); updateLogin.uid = id_login.ToString(); updateLogin.name = updateName.Text; updateLogin.email = updateEmail.Text; updateLogin.password = myAttributes.password; if (isCompanyChanged == true) { updateLogin.cfid = "0"; } else if (isCompanyChanged == false) { updateLogin.cfid = myAttributes.cfid.ToString(); } updateLogin.type = "Recruiter"; var firebase = new FirebaseClient(FirebaseURL); await firebase.Child("users").Child(key).PutAsync(updateLogin); // Update Recruiter Recruiter updateRecruiter = new Recruiter(); updateRecruiter.recruiterid = id_recruiter.ToString(); updateRecruiter.name = updateName.Text; updateRecruiter.email = updateEmail.Text; updateRecruiter.password = myAttributes.password; updateRecruiter.company = string.Format("{0}", company.SelectedItem); var allRecruiters = await firebase.Child("recruiters").OnceAsync <Recruiter>(); string recruiterKey = ""; foreach (var recruiter in allRecruiters) { if (recruiter.Object.email == myAttributes.email) { recruiterKey = recruiter.Key; } } await firebase.Child("recruiters").Child(recruiterKey).PutAsync(updateRecruiter); // Update MyAttributes MyAttributes updateMyAttributes = new MyAttributes(); updateMyAttributes.id = 1; updateMyAttributes.name = updateRecruiter.name; updateMyAttributes.email = updateRecruiter.email; updateMyAttributes.password = myAttributes.password; updateMyAttributes.type = "Recruiter"; updateMyAttributes.attribute1 = updateRecruiter.company; updateMyAttributes.attribute2 = ""; updateMyAttributes.attribute3 = ""; updateMyAttributes.attribute4 = ""; if (isCompanyChanged == true) { updateMyAttributes.cfid = 0; } else if (isCompanyChanged == false) { updateMyAttributes.cfid = myAttributes.cfid; } updateMyAttributes.loginid = id_login; updateMyAttributes.typeid = id_recruiter; updateMyAttributes.rememberme = myAttributes.rememberme; db_attributes.InsertOrReplace(updateMyAttributes); progressBar.Visibility = ViewStates.Invisible; Android.Support.V4.App.FragmentTransaction trans = FragmentManager.BeginTransaction(); trans.Replace(Resource.Id.profile_root_frame, new ProfileFragment()); trans.Commit(); } catch { progressBar.Visibility = ViewStates.Invisible; Toast.MakeText(this.Activity, "Invalid Email Address", ToastLength.Short).Show(); } }
public async Task <JsonWebToken> LoginAsync(string email, string password) { var talentUser = (await _userRepository.Get(x => x.Login.Username == email)).FirstOrDefault(); string userRole = "talent"; var login = new Login(); var employerUser = new Employer(); var recruiterUser = new Recruiter(); if (talentUser != null) { login = talentUser.Login; //reactivate account if the account is currently deactivated if (talentUser.IsDeleted) { talentUser.IsDeleted = false; await _userRepository.Update(talentUser); } } else if (talentUser == null) { employerUser = (await _employerRepository.Get(x => x.Login.Username == email)).FirstOrDefault(); if (employerUser != null) { userRole = "employer"; login = employerUser.Login; //reactivate account if the account is deactivated if (employerUser.IsDeleted) { employerUser.IsDeleted = false; await _employerRepository.Update(employerUser); } } } if (talentUser == null && employerUser == null) { recruiterUser = (await _recruitorRepository.Get(x => x.Login.Username == email)).FirstOrDefault(); if (recruiterUser != null) { userRole = "recruiter"; login = recruiterUser.Login; //reactivate account if the account is deactivated if (recruiterUser.IsDeleted) { recruiterUser.IsDeleted = false; await _recruitorRepository.Update(recruiterUser); } } } else if (talentUser == null && employerUser == null && recruiterUser == null) { throw new ApplicationException("Invalid credentials"); } var passwordCorrect = await VerifyPassword(login, password); if (!passwordCorrect) { throw new ApplicationException("Invalid credentials"); } return(_jwtHandler.Create(login.Id, userRole, false)); }
private XmlResource CreateUpdatedResource(Enums.ResourceType resourceType, string id, string fieldAlias, string fieldValue) { XmlResource result = null; switch (resourceType) { case Enums.ResourceType.Client: result = new Client() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; case Enums.ResourceType.Activity: result = new Activity() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; case Enums.ResourceType.Sales: result = new Sales() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; case Enums.ResourceType.Contract: result = new Contract() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; case Enums.ResourceType.Process: result = new Process() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; case Enums.ResourceType.Job: result = new Job() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; case Enums.ResourceType.Recruiter: result = new Recruiter() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; case Enums.ResourceType.Resume: result = new Resume() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; case Enums.ResourceType.Candidate: result = new Candidate() { Id = id }; result.DictionaryValues[fieldAlias] = fieldValue; break; } return(result); }
public LogicResponseHandler <string> AddEntity(string category, string city, ICollection <Comment> comments, DateTime deadlineAplications, bool deleted, string department, string description, string duration, DateTime endDate, ICollection <File> files, Firm firm, string firmOrganizerid, bool hidden, Image image, string internshipId, string internshipPostPhoto, string keywords, DateTime lastUpdated, int positionsAvailable, Recruiter recruiter, string recruiterResponsibleId, DateTime startDate, ICollection <StudentInternship> studentInternships, ICollection <StudentInternship> studentInternships1, string title, string typeJob) { var result = _repo.AddEntity( new Internship { Category = category, City = city, Comments = comments, DeadlineApplications = deadlineAplications, Deleted = deleted, Department = department, Description = description, Duration = duration, EndDate = endDate, Files = files, Firm = firm, FirmOrganizerId = firmOrganizerid, Hidden = hidden, Image = image, InternshipId = internshipId, InternshipPostPhoto = internshipPostPhoto, Keywords = keywords, LastUpdated = lastUpdated, PositionsAvailable = positionsAvailable, Recruiter = recruiter, RecruiterResponsibleId = recruiterResponsibleId, StartDate = startDate, StudentInternships = studentInternships, Title = title, TypeJob = typeJob }); if (result.Succes) { return(new LogicResponseHandler <string> { Status = true, Content = "Succes!" }); } else { return(new LogicResponseHandler <string> { Status = false, Content = result.Container }); } }
public RecruiterShould() { this._sut = new Recruiter(); }
public LogicResponseHandler <string> UpdateEntity(string oldGuid, string category, string city, ICollection <Comment> comments, DateTime deadlineAplications, bool deleted, string department, string description, string duration, DateTime endDate, ICollection <File> files, Firm firm, string firmOrganizerid, bool hidden, Image image, string internshipId, string internshipPostPhoto, string keywords, DateTime lastUpdated, int positionsAvailable, Recruiter recruiter, string recruiterResponsibleId, DateTime startDate, ICollection <StudentInternship> studentInternships, ICollection <StudentInternship> studentInternships1, string title, string typeJob, string firmId, ICollection <Internship> internships, string logo, string name) { var result = _repo.UpdateEntity( new Firm { Deleted = deleted, Description = description, FirmId = firmId, Image = image, Internships = internships, Logo = logo, Name = name //NumberOfEmployees= numberOfEmployees, //Recruiters = recruiters }); if (result.Succes) { return(new LogicResponseHandler <string> { Status = true, Content = "Succes!" }); } else { return(new LogicResponseHandler <string> { Status = false, Content = result.Container }); } }
public IActionResult CreateComment(int id, string email) { Recruiter rec = context_.Recruiters.Find(id); return(View(rec)); }
public IActionResult AddComment(int?id) { Recruiter r = context_.recruiters.Find(id); return(View(r)); }
public void TestCreateUpdateRecruiterInOneRequest() { List <Recruiter> recruiterList = new List <Recruiter>(); string clientId = (new ResourceCreator <Client>(PublicApiAdapter.CreateAdapterForDefaultConnection())).Create(); string recruiterId = CreateRecruiterResourceSpecifiedData(clientId); Recruiter recruiter1 = new Recruiter { Id = recruiterId, Owner = "1", Name = "Jacky Nam 1", Client = clientId, Division = "Sample Text 1", Telephone = "083-08125-235", Mail = "*****@*****.**", ZipCode = "0123", Memo = "Sample Text Memo 1" }; Recruiter recruiter2 = new Recruiter { Id = "-1", Owner = "1", Name = "Jacky Nam 2", Client = clientId, Division = "Sample Text 2", Telephone = "083-08125-235", Mail = "*****@*****.**", ZipCode = "0123", Memo = "Sample Text Memo 2" }; recruiterList.Add(recruiter1); recruiterList.Add(recruiter2); List <string> idList = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(recruiterList); int resourceId = -1; bool parsed = Int32.TryParse(idList[0], out resourceId); Assert.IsTrue(parsed); Assert.IsTrue(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Recruiter")); PublicAPISetUp.ListRecruiterId.Add(idList[0]); PublicAPISetUp.ListRecruiterId.Add(idList[1]); PublicAPISetUp.ListClientId.Add(clientId); //Verify data Dictionary <string, object> fields1 = new Dictionary <string, object>() { { "Recruiter.P_Name", recruiter1.Name }, { "Recruiter.P_Owner", recruiter1.Owner }, { "Recruiter.P_Client", recruiter1.Client }, { "Recruiter.P_Division", recruiter1.Division }, { "Recruiter.P_Telephone", recruiter1.Telephone }, { "Recruiter.P_Mail", recruiter1.Mail }, { "Recruiter.P_Zipcode", recruiter1.ZipCode }, { "Recruiter.P_Memo", recruiter1.Memo } }; VerifyFieldData(Int32.Parse(idList[0]), fields1); Dictionary <string, object> fields2 = new Dictionary <string, object>() { { "Recruiter.P_Name", recruiter2.Name }, { "Recruiter.P_Owner", recruiter2.Owner }, { "Recruiter.P_Client", recruiter2.Client }, { "Recruiter.P_Division", recruiter2.Division }, { "Recruiter.P_Telephone", recruiter2.Telephone }, { "Recruiter.P_Mail", recruiter2.Mail }, { "Recruiter.P_Zipcode", recruiter2.ZipCode }, { "Recruiter.P_Memo", recruiter2.Memo } }; VerifyFieldData(Int32.Parse(idList[1]), fields2); }
/// <summary> /// Destroys the Instance /// </summary> public static void DestroyInstance() { _instance = null; }
public async Task SaveJobOffer_UpdatesAJobOfferSuccessfuly_WhenJobOfferExistsAndHasValidInformation() { //Arrange var recruiter = new Recruiter() { FirstName = "Maidana", LastName = "Patricia", IdentityCard = "28123456" }; await _recruiterService.CreateRecruiterAsync(recruiter); var company = new Company("Acme", "Software"); await _recruiterService.AddClientAsync(company, recruiter.Id); var skill1 = new Skill() { Name = "C#" }; var skill2 = new Skill() { Name = "Javascript" }; var skill3 = new Skill() { Name = "React" }; await _skillRepository.UpsertAsync(skill1); await _skillRepository.UpsertAsync(skill2); await _skillRepository.UpsertAsync(skill3); var jobOffer = await _recruiterService.GetNewJobOffer(recruiter.Id); jobOffer.Title = "Analista Funcional"; jobOffer.Description = "Se necesita analista funcional con bla bla bla"; jobOffer.RecruiterId = recruiter.Id; jobOffer.Date = DateTime.Now.Date; jobOffer.ContractInformation = new ContractCondition() { KindOfContract = "FullTime", StartingFrom = "As soon as possible", WorkingDays = "Montay to Friday" }; jobOffer.AddSkillRequired(new SkillRequired(skill1, 5, true)); jobOffer.AddSkillRequired(new SkillRequired(skill2, 4, false)); jobOffer.AddSkillRequired(new SkillRequired(skill3, 2, false)); jobOffer.CompanyId = company.Id; await _recruiterService.SaveJobOfferAsync(jobOffer); var jobOfferSaved = await _jobOfferRepository.GetByIdAsync(jobOffer.Id); const string newTitle = "New title"; //Act jobOfferSaved.Title = newTitle; await _recruiterService.SaveJobOfferAsync(jobOfferSaved); var jobOfferUpdated = await _jobOfferRepository.GetByIdAsync(jobOfferSaved.Id); //Assert Assert.AreEqual(newTitle, jobOfferSaved.Title); }
public async Task SaveJobOffer_CreatesSuccessfullyANewJobOffer_WhenJobOfferDataIsCorrect() { //Arrange var skill1 = new Skill() { Name = "C#" }; var skill2 = new Skill() { Name = "Javascript" }; var skill3 = new Skill() { Name = "React" }; await _skillRepository.UpsertAsync(skill1); await _skillRepository.UpsertAsync(skill2); await _skillRepository.UpsertAsync(skill3); var recruiter = new Recruiter() { FirstName = "Maidana", LastName = "Patricia", IdentityCard = "28123456" }; await _recruiterService.CreateRecruiterAsync(recruiter); var company = new Company("Acme", "Software"); await _recruiterService.AddClientAsync(company, recruiter.Id); var jobOffer = await _recruiterService.GetNewJobOffer(recruiter.Id); jobOffer.Title = "Analista Funcional"; jobOffer.Description = "Se necesita analista funcional con bla bla bla"; jobOffer.RecruiterId = recruiter.Id; jobOffer.Date = DateTime.Now.Date; jobOffer.ContractInformation = new ContractCondition() { KindOfContract = "FullTime", StartingFrom = "As soon as possible", WorkingDays = "Montay to Friday" }; jobOffer.AddSkillRequired(new SkillRequired(skill1, 5, true)); jobOffer.AddSkillRequired(new SkillRequired(skill2, 4, false)); jobOffer.AddSkillRequired(new SkillRequired(skill3, 2, false)); jobOffer.CompanyId = company.Id; //Act await _recruiterService.SaveJobOfferAsync(jobOffer); var jobOfferSaved = await _jobOfferRepository.GetByIdAsync(jobOffer.Id); var companySaved = await _companyRepository.GetCompanyAsync(company.Name, company.Activity); //Assert Assert.AreEqual(companySaved.Id, jobOfferSaved.CompanyId, "The company created is different than the one assigned to the job offer"); Assert.AreEqual(jobOffer, jobOfferSaved, "Job offer was not saved"); Assert.AreEqual(JobOfferState.WorkInProgress, jobOfferSaved.State, "Job offer created has a wrong state"); Assert.AreEqual(recruiter.Id, jobOfferSaved.RecruiterId); }
private static void Main(string[] args) { var mongoClient = new MongoClient(); mongoClient.DropDatabase("JobOfferDatabase"); var database = mongoClient.GetDatabase("JobOfferDatabase"); var cSharp = new Skill() { Name = "C#" }; var javascript = new Skill() { Name = "Javascript" }; var react = new Skill() { Name = "React" }; var docker = new Skill() { Name = "Docker" }; var java = new Skill() { Name = "Java" }; var skillRepository = new SkillRepository(database); Task.Run(async() => await skillRepository.UpsertAsync(cSharp)).Wait(); Task.Run(async() => await skillRepository.UpsertAsync(javascript)).Wait(); Task.Run(async() => await skillRepository.UpsertAsync(react)).Wait(); Task.Run(async() => await skillRepository.UpsertAsync(docker)).Wait(); Task.Run(async() => await skillRepository.UpsertAsync(java)).Wait(); var companyRepository = new CompanyRepository(database); var recruiterRepository = new RecruiterRepository(database); var jobOfferRepository = new JobOfferRepository(database); var personRepository = new PersonRepository(database); var accountRepository = new AccountRepository(database); var recruiterService = new RecruiterService(companyRepository, recruiterRepository, jobOfferRepository, personRepository, accountRepository); var recruiter = new Recruiter(); recruiter.AddClient(new Company("Acme", "Software")); recruiter.IdentityCard = "28.999.999"; recruiter.FirstName = "Patricia"; recruiter.LastName = "Maidana"; recruiter.SetStudy(new Study("UBA", "Lic.RRHH", StudyStatus.Completed)); recruiter.SetPreviousJob(new Job("Coto", "HR Analyst", DateTime.Now.AddYears(-6), true)); recruiter.SetAbility(new Ability(javascript, 9)); var company1 = new Company("Acme", "software"); companyRepository.UpsertAsync(company1).Wait(); recruiterService.CreateRecruiterAsync(recruiter).Wait(); var jobOffer = Task.Run(() => { RecruiterService recruiterService1 = recruiterService; return(recruiterService1.GetNewJobOffer(recruiter.Id)); }).Result; jobOffer.Date = DateTime.Now.Date; jobOffer.Title = "Analista programador"; jobOffer.CompanyId = company1.Id; jobOffer.Zone = "Palermo"; jobOffer.Description = "Para importante empresa ubicada en San Telmo, estamos en búsqueda de desarrollador fullstack con " + "al menos 3 años de experiencia utilizando React y NodeJs.Quien se incorpore estará participando dentro " + "de un proyecto de inteligencia artifical"; jobOffer.AddSkillRequired(new SkillRequired(javascript, 5, true)); jobOffer.AddSkillRequired(new SkillRequired(react, 3)); jobOffer.Language = "Ingles"; jobOffer.LanguageLevel = LanguageLevel.Advance; jobOffer.IsLanguageMandatory = true; jobOffer.ContractInformation = new ContractCondition() { StartingFrom = "Inmediata", KindOfContract = "Relación de dependencia", WorkingDays = "Lunes a viernes 9 a 18" }; recruiterService.SaveJobOfferAsync(jobOffer).Wait(); // var company2 = new Company("KaizenRH", "software"); companyRepository.UpsertAsync(company2).Wait(); var jobOffer2 = Task.Run(() => recruiterService.GetNewJobOffer(recruiter.Id)).Result; jobOffer2.Date = DateTime.Now.Date; jobOffer2.Title = "JAVA Full Stack Developer"; jobOffer2.CompanyId = company2.Id; jobOffer2.Zone = "Las Cañitas"; jobOffer2.Description = "En KaizenRH buscamos Python Developer Junior para trabajar en interesantes proyectos dentro de Startup en expansión LATAM dedicada a la automatización de procesos IT y negocios."; jobOffer2.AddSkillRequired(new SkillRequired(javascript, 5, true)); jobOffer2.AddSkillRequired(new SkillRequired(react, 3)); jobOffer2.AddSkillRequired(new SkillRequired(java, 6, true)); jobOffer2.Language = "Ingles"; jobOffer2.LanguageLevel = LanguageLevel.Intermediate; jobOffer2.ContractInformation = new ContractCondition() { StartingFrom = "Inmediata", KindOfContract = "Relación de dependencia", WorkingDays = "Lunes a viernes 9 a 18" }; recruiterService.SaveJobOfferAsync(jobOffer2).Wait(); // var company3 = new Company("ADN Recursos Humanos", "Seleccion de personal"); companyRepository.UpsertAsync(company3).Wait(); var jobOffer3 = Task.Run(() => recruiterService.GetNewJobOffer(recruiter.Id)).Result; jobOffer3.Date = DateTime.Now.Date; jobOffer3.Title = "Sr. C# Backend Developer/Engineer"; jobOffer3.CompanyId = company3.Id; jobOffer3.Zone = "Microcentro"; jobOffer3.Description = "ADN - Recursos Humanos estamos en la búsqueda de un Sr. Python Backend Developer/Engineer, para Importante Empresa de Tecnología"; jobOffer3.AddSkillRequired(new SkillRequired(cSharp, 5)); jobOffer3.AddSkillRequired(new SkillRequired(javascript, 2, true)); jobOffer3.ContractInformation = new ContractCondition() { StartingFrom = "Inmediata", KindOfContract = "Relación de dependencia", WorkingDays = "Lunes a viernes 9 a 18" }; recruiterService.SaveJobOfferAsync(jobOffer3).Wait(); recruiterService.PublishJobOffer(jobOffer2).Wait(); recruiterService.PublishJobOffer(jobOffer3).Wait(); recruiterService.FinishJobOffer(jobOffer3).Wait(); var pRepo = new RecruiterRepository(database); var aRepo = new AccountRepository(database); var person = pRepo.GetByIdentityCardAsync("28.999.999").Result; var account = new Account() { Id = Guid.NewGuid().ToString(), PersonId = person.Id, Email = "*****@*****.**", Password = "******", IsRecruiter = true }; aRepo.UpsertAsync(account).Wait(); Console.WriteLine("Agregado correctamente!"); Console.ReadKey(); }
public async Task <ActionResult> Register([Bind(Exclude = "VerCode")] RegisterViewModel model, FormCollection form) { int typeId = 0; if (ModelState.IsValid) { var user = new ApplicationUser() { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, UserType = model.UserType, VerCode = randomString(32) }; if (user.UserType.Equals("R")) { string compname = form["company"].ToString(); var compid = from c in db.Companies where c.CompName == compname select c.CompId; Recruiter r = new Recruiter { Department = form["dept"].ToString(), JobTitle = form["jobtitle"].ToString(), HasAccess = "T", CompanyCompId = Convert.ToInt32(compid), UserName = user.Id }; db.Recruiters.Add(r); db.SaveChanges(); typeId = r.RecId; } else if (user.UserType.Equals("J")) { JobSeeker js = new JobSeeker { SkillSummary = form["sksum"].ToString(), Visibility = "T", UserName = user.Id }; db.JobSeekers.Add(js); db.SaveChanges(); typeId = js.JSId; } else if (user.UserType.Equals("C")) { Company c = new Company { CompName = user.FirstName + user.LastName, CompCode = form["code"].ToString(), CompDescription = form["desc"].ToString(), NumFollowers = null, UserName = user.Id }; db.Companies.Add(c); db.SaveChanges(); typeId = c.CompId; } IdentityResult result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInAsync(user, isPersistent : false); if (profileLink(user.UserType, typeId) != null) { return(View(profileLink(user.UserType, typeId), typeId)); // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>"); } else { return(RedirectToAction("Index", "Home")); } } else { AddErrors(result); } } // If we got this far, something failed, redisplay form return(View(model)); }
//Prepare some reference resource private void PrepareData() { ////////////////////////////////////////////////////////////////////////////////////// // NEW Client clientId = (new ResourceCreator <Client>(PublicApiAdapter.CreateAdapterForDefaultConnection())).Create(); Assume.That(!string.IsNullOrEmpty(clientId), "Unable to create Candidate"); // Adding id into the static list for further cleanup PublicAPISetUp.ListClientId.Add(clientId); ////////////////////////////////////////////////////////////////////////////////////// // NEW Recruiter Recruiter recruiter = new Recruiter() { Id = "-1", Owner = "1", Client = clientId }; // Create New Resource recruiterId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(recruiter, cleanupAction: null); Assume.That(!string.IsNullOrEmpty(recruiterId), "Unable to create Recruiter"); // Adding id into the static list for further cleanup PublicAPISetUp.ListRecruiterId.Add(recruiterId); ////////////////////////////////////////////////////////////////////////////////////// // NEW Job Job job = new Job() { Id = "-1", Owner = "1", Client = clientId, Recruiter = recruiterId, }; jobId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(job, cleanupAction: null); Assume.That(!string.IsNullOrEmpty(jobId), "Unable to create new resource"); // Adding id into the static list for further cleanup PublicAPISetUp.ListJobId.Add(jobId); ////////////////////////////////////////////////////////////////////////////////////// // NEW Candidate Candidate Candidate = new Candidate() { Id = "-1", Owner = "1", }; // Create New Resource candidateId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(Candidate, cleanupAction: null); Assume.That(!string.IsNullOrEmpty(candidateId), "Unable to create new resource"); // Adding id into the static list for further cleanup PublicAPISetUp.ListCandidateId.Add(candidateId); ////////////////////////////////////////////////////////////////////////////////////// // NEW Resume Resume resume = new Resume() { Id = "-1", Candidate = candidateId, Owner = "1", }; // Create New Resource resumeId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resume, cleanupAction: null); Assume.That(!string.IsNullOrEmpty(resumeId), "Unable to create new resource"); // Adding id into the static list for further cleanup PublicAPISetUp.ListResumeId.Add(resumeId); }
public async Task <List <JobOffer> > GetActiveJobOffer(Recruiter recruiter) { return(await Collection.Find(item => item.IsActive == true && item.Owner == recruiter).ToListAsync()); }
private void SetTarget(Recruiter recruiter, RecruiterViewModel model) { }
private async void CreateUser() { ProgressBar progressBar = FindViewById <ProgressBar>(Resource.Id.circularProgress); progressBar.Visibility = ViewStates.Visible; try { string dbPath_attributes = System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "attributes.db3"); var db_attributes = new SQLiteConnection(dbPath_attributes); MyAttributes userAttributes = db_attributes.Get <MyAttributes>(1); // Create user object User newUser = new User(); newUser.name = userAttributes.name; newUser.email = userAttributes.email; newUser.password = userAttributes.password; newUser.type = userAttributes.type; newUser.cfid = "0"; // Query user database for number of users, assign user id var firebase = new FirebaseClient(FirebaseURL); var items = await firebase.Child("users").OnceAsync <User>(); int numUsers = items.Count(); newUser.uid = (numUsers + 1).ToString(); userAttributes.loginid = Convert.ToInt32(newUser.uid); db_attributes.Update(userAttributes); // insert object into user database var item = await firebase.Child("users").PostAsync(newUser); // create type object if (userAttributes.type == "Student") { Student newStudent = new Student(); newStudent.name = userAttributes.name; newStudent.email = userAttributes.email; newStudent.password = userAttributes.password; newStudent.school = userAttributes.attribute1; newStudent.gradterm = userAttributes.attribute2; newStudent.major = userAttributes.attribute3; newStudent.gpa = userAttributes.attribute4; // Query student database for number of students, assign student id var studentItems = await firebase.Child("students").OnceAsync <Student>(); int numStudents = studentItems.Count(); newStudent.studentid = (numStudents + 1).ToString(); userAttributes.typeid = numStudents + 1; db_attributes.Update(userAttributes); // insert object into student database var studentItem = await firebase.Child("students").PostAsync(newStudent); } else if (userAttributes.type == "Recruiter") { Recruiter newRecruiter = new Recruiter(); newRecruiter.name = userAttributes.name; newRecruiter.email = userAttributes.email; newRecruiter.password = userAttributes.password; newRecruiter.company = userAttributes.attribute1; // Query recruiter database for number of students, assign recruiter id var recruiterItems = await firebase.Child("recruiters").OnceAsync <Recruiter>(); int numRecruiters = recruiterItems.Count(); newRecruiter.recruiterid = (numRecruiters + 1).ToString(); userAttributes.typeid = numRecruiters + 1; db_attributes.Update(userAttributes); // insert object into recruiter database var recruiterItem = await firebase.Child("recruiters").PostAsync(newRecruiter); } progressBar.Visibility = ViewStates.Invisible; var advanceIntent = new Intent(this, typeof(homeScreen2)).PutExtra("UserId", newUser.uid); StartActivity(advanceIntent); Finish(); } catch (Exception ex) { Toast.MakeText(this, ex.ToString(), ToastLength.Long).Show(); progressBar.Visibility = ViewStates.Invisible; } }
public async Task <bool> UpdateEmployerProfile(EmployerProfileViewModel employer, string updaterId, string role) { try { if (employer.Id != null) { switch (role) { case "employer": Employer existingEmployer = (await _employerRepository.GetByIdAsync(employer.Id)); existingEmployer.CompanyContact = employer.CompanyContact; existingEmployer.PrimaryContact = employer.PrimaryContact; existingEmployer.ProfilePhoto = employer.ProfilePhoto; existingEmployer.ProfilePhotoUrl = employer.ProfilePhotoUrl; existingEmployer.DisplayProfile = employer.DisplayProfile; existingEmployer.UpdatedBy = updaterId; existingEmployer.UpdatedOn = DateTime.Now; var newSkills = new List <UserSkill>(); //new middle var [List] foreach (var item in employer.Skills) //each item in para sending {obj} { var skill = existingEmployer.Skills.SingleOrDefault(x => x.Id == item.Id); //find each existing data if (skill == null) //if cannot find such data { skill = new UserSkill //create a new obj { Id = ObjectId.GenerateNewId().ToString(), //create a new id IsDeleted = false //set the deleted tag to be false }; } UpdateSkillFromView(item, skill); //assign each item of para sending data to each existing data newSkills.Add(skill); //feed each revised data to the middle var } existingEmployer.Skills = newSkills; //substitute the existing props with the middle var await _employerRepository.Update(existingEmployer); //update after substitution break; case "recruiter": Recruiter existingRecruiter = (await _recruiterRepository.GetByIdAsync(employer.Id)); existingRecruiter.CompanyContact = employer.CompanyContact; existingRecruiter.PrimaryContact = employer.PrimaryContact; existingRecruiter.ProfilePhoto = employer.ProfilePhoto; existingRecruiter.ProfilePhotoUrl = employer.ProfilePhotoUrl; existingRecruiter.DisplayProfile = employer.DisplayProfile; existingRecruiter.UpdatedBy = updaterId; existingRecruiter.UpdatedOn = DateTime.Now; var newRSkills = new List <UserSkill>(); foreach (var item in employer.Skills) { var skill = existingRecruiter.Skills.SingleOrDefault(x => x.Id == item.Id); if (skill == null) { skill = new UserSkill { Id = ObjectId.GenerateNewId().ToString(), IsDeleted = false }; } UpdateSkillFromView(item, skill); newRSkills.Add(skill); } existingRecruiter.Skills = newRSkills; await _recruiterRepository.Update(existingRecruiter); break; } return(true); } return(false); } catch (MongoException e) { return(false); } }
public async Task <ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, FullName = model.FullName, Address = model.Address, PhoneNumber = model.PhoneNo, CreatedAt = DateTime.Now, Role = model.Role }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false); // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>"); Entities db = new Entities(); AspNetUserRole ab = new AspNetUserRole(); ab.UserId = user.Id; if (user.Role == "Jobseeker") { ab.RoleId = "3"; Resume rs = new Resume(); rs.Address = user.Address; rs.MobileNo = user.PhoneNumber; rs.UserId = user.Id; rs.Name = user.FullName; db.Resumes.Add(rs); db.SaveChanges(); ResumeFile rf = new ResumeFile(); rf.ResumeId = rs.Id; rf.Path = "~/ADD RESUME"; db.ResumeFiles.Add(rf); db.SaveChanges(); } if (user.Role == "Recruiter") { ab.RoleId = "2"; Recruiter re = new Recruiter(); re.Name = user.FullName; re.UserId = user.Id; db.Recruiters.Add(re); db.SaveChanges(); } ab.AssignAt = DateTime.Now; db.AspNetUserRoles.Add(ab); db.SaveChanges(); return(RedirectToAction("Index", "Home")); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task CreateRecruiter([FromBody] Recruiter recruiter) { await _recruiterService.CreateRecruiterAsync(recruiter); }
public override void SetUp() { base.SetUp(); var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection(); ////////////////////////////////////////////////////////////////////////////////////// // NEW Client clientId = (new ResourceCreator <Client>(publicApiAdapter)).Create(); Assume.That(!string.IsNullOrEmpty(clientId), "Unable to create Client"); // Adding id into the static list for further cleanup listClientId.Add(clientId); ////////////////////////////////////////////////////////////////////////////////////// // NEW Recruiter Recruiter recruiter = new Recruiter() { Id = "-1", Owner = "1", Client = clientId, Name = "Recruiter " + DateTime.Now.ToString("yyyy/MM/dd hh:mm:ss") }; // Create New Resource recruiterId = publicApiAdapter.WriteSuccess(recruiter, cleanupAction: null); Assume.That(!string.IsNullOrEmpty(recruiterId), "Unable to create Recruiter"); // Adding id into the static list for further cleanup listRecruiterId.Add(recruiterId); ////////////////////////////////////////////////////////////////////////////////////// // NEW Job Job job = new Job() { Id = "-1", Owner = "1", Client = clientId, Recruiter = recruiterId, }; jobId = publicApiAdapter.WriteSuccess(job, cleanupAction: null); Assume.That(!string.IsNullOrEmpty(jobId), "Unable to create Job"); // Adding id into the static list for further cleanup listJobId.Add(jobId); ////////////////////////////////////////////////////////////////////////////////////// // NEW Resume resumeId = (new ResourceCreator <Resume>(publicApiAdapter)).Create(); Assume.That(!string.IsNullOrEmpty(resumeId), "Unable to create Resume"); // Adding id into the static list for further cleanup listResumeId.Add(resumeId); ////////////////////////////////////////////////////////////////////////////////////// // NEW Sales salesId = WriteSales(); Assume.That(!string.IsNullOrEmpty(salesId), "Unable to create Sales"); // Adding id into the static list for further cleanup listSalesId.Add(salesId); }
/// <summary> /// Register new user /// </summary> /// <param name="user"></param> public async Task <JsonWebToken> SignUp(CreateUser user) { try { if (user == null) { throw new ApplicationException("Incomplete register request - user is null"); } if (user.Email == null) { throw new ApplicationException("Incomplete register request - user's email is null"); } if (user.Password == null || user.Password.Length == 0) { throw new ApplicationException("Incomplete register request - Password is null"); } // hash password var passHash = _encryptPassword.CreateHash(user.Password); //var passHash = new PBKDF2(user.Password,SALT_BYTES,PBKDF2_ITERATIONS,"HMACSHA512"); var UId = Guid.NewGuid(); var objectId = ObjectId.GenerateNewId().ToString(); var login = new Login() { Id = objectId, UId = UId, Username = user.Email, PasswordHash = passHash, IsDisabled = false, EmailAddressAuthorized = true, ExpiredOn = DateTime.UtcNow.AddHours(24), PasswordFormat = PBKDF2_ITERATIONS, TermsAccepted = user.TermsConditionsAccepted }; if (user.UserRole == "recruiter") { var newRecruitor = new Recruiter() { Id = objectId, CreatedOn = DateTime.UtcNow, IsDeleted = false, UId = UId, Login = login }; newRecruitor.CompanyContact.Email = user.Email; newRecruitor.CompanyContact.Name = user.CompanyName; await _recruitorRepository.Add(newRecruitor); return(_jwtHandler.Create(newRecruitor.Id, user.UserRole, true)); } else if (user.UserRole == "employer") { var newEmployer = new Employer() { Id = objectId, CreatedOn = DateTime.UtcNow, IsDeleted = false, UId = UId, Login = login, }; newEmployer.CompanyContact.Email = user.Email; newEmployer.CompanyContact.Name = user.CompanyName; await _employerRepository.Add(newEmployer); return(_jwtHandler.Create(newEmployer.Id, user.UserRole, true)); } else { var newTalent = new User() { Id = objectId, FirstName = user.FirstName, LastName = user.LastName, CreatedOn = DateTime.UtcNow, IsDeleted = false, UId = UId, Login = login, }; await _userRepository.Add(newTalent); return(_jwtHandler.Create(newTalent.Id, user.UserRole, true)); } } catch (Exception ex) { throw new ApplicationException("Register error - " + ex.Message); } }
public async Task UpdateRecruiter_SaveCruiterSuccessfully_WhenRecruiterDataIsCorrectAndRecruiterExists() { //Arrange var recruiter = new Recruiter() { FirstName = "Patricia", LastName = "Maidana", IdentityCard = "28123456" }; recruiter.AddClientCompany(new Company("Acme", "Software")); recruiter.SetPreviousJob(new Job("Accenture", "Sr.Talent Adquision", new DateTime(2015, 5, 1), true)); recruiter.SetPreviousJob(new Job("Accenture", "Sr.Talent Adquision", new DateTime(2014, 1, 1), false, new DateTime(2015, 4, 30))); recruiter.SetStudy(new Study("UBA", "Lic.Relaciones del Trabajo", StudyStatus.Completed)); var cSharp = new Skill() { Name = "C#" }; var javascript = new Skill() { Name = "Javascript" }; var react = new Skill() { Name = "React" }; await _skillRepository.UpsertAsync(cSharp); await _skillRepository.UpsertAsync(javascript); await _skillRepository.UpsertAsync(react); var cSharpAbility = new Ability(cSharp, 10); var javascriptAbility = new Ability(javascript, 8); recruiter.SetAbility(cSharpAbility); recruiter.SetAbility(javascriptAbility); await _service.CreateRecruiterAsync(recruiter); //Act var savedRecruiter = await _service.GetRecruiterAsync(recruiter); var previousJob = savedRecruiter.JobHistory.Where(j => j.CompanyName == "Accenture" && j.From.Date == new DateTime(2014, 1, 1).Date).Single(); var newJob = (Job)previousJob.Clone(); newJob.CompanyName = "Globant"; savedRecruiter.SetPreviousJob(newJob, previousJob); var reactAbility = new Ability(react, 5); savedRecruiter.SetAbility(reactAbility, cSharpAbility); await _service.UpdateRecruiterAsync(savedRecruiter); var updatedRecruiter = await _service.GetRecruiterAsync(savedRecruiter); //Assert Assert.AreEqual("Globant", updatedRecruiter.JobHistory.Single(j => j == newJob).CompanyName, "Company name of a recruiter was now updated"); Assert.IsTrue(updatedRecruiter.Abilities.Count() == 2); Assert.IsNotNull(updatedRecruiter.Abilities.SingleOrDefault(a => a.Skill == react)); }
public static void Initialize(TrackerContext context) { //context.Database.EnsureCreated(); //Look for any jobs if (context.Jobs.Any()) { return; //db has been seeded } var sectors = new Sector[] { new Sector { Name = "Tech", }, new Sector { Name = "Finance" } }; context.Sectors.AddRange(sectors); context.SaveChanges(); var companies = new Company[] { new Company { CompanyName = "Amazon", Size = Size.Huge, SectorID = sectors.Single(s => s.Name == "Tech").SectorID }, new Company { CompanyName = "Microsoft", Size = Size.Huge, SectorID = sectors.Single(s => s.Name == "Tech").SectorID } }; context.Companies.AddRange(companies); context.SaveChanges(); var jobs = new Job[] { new Job { Title = "Unemployed SDE", Company = companies.Single(i => i.CompanyName == "Amazon"), ApplicationDate = DateTime.Parse("2020-07-01"), City = "Seattle", State = "Washington", Country = "USA", Interview = false, Rejected = true, LastChecked = DateTime.Parse("2020-08-01"), LastContact = DateTime.Parse("2020-07-01") }, new Job { Title = "SDE", Company = companies.Single(i => i.CompanyName == "Amazon"), ApplicationDate = DateTime.Parse("2020-06-01"), City = "Seattle", State = "Washington", Country = "USA", Interview = false, Rejected = true, LastChecked = DateTime.Parse("2020-07-01"), LastContact = DateTime.Parse("2020-06-01") }, new Job { Title = "SDE Rejecter", Company = companies.Single(i => i.CompanyName == "Amazon"), ApplicationDate = DateTime.Parse("2020-05-01"), City = "Seattle", State = "Washington", Country = "USA", Interview = false, Rejected = true, LastChecked = DateTime.Parse("2020-05-01"), LastContact = DateTime.Parse("2020-05-01") }, new Job { Title = "Unemployed SDE", Company = companies.Single(i => i.CompanyName == "Microsoft"), ApplicationDate = DateTime.Parse("2020-03-01"), City = "Seattle", State = "Washington", Country = "USA", Interview = false, Rejected = true, LastChecked = DateTime.Parse("2020-05-01"), LastContact = DateTime.Parse("2020-03-01") } }; context.Jobs.AddRange(jobs); context.SaveChanges(); var recruiters = new Recruiter[] { new Recruiter { FirstMidName = "Jim", LastName = "Jimerson", LastContactDate = DateTime.Parse("2020-07-05") }, new Recruiter { FirstMidName = "Kim", LastName = "Kimerson", LastContactDate = DateTime.Parse("2020-07-05") } }; context.Recruiters.AddRange(recruiters); context.SaveChanges(); var locations = new Location[] { new Location { RecruiterID = recruiters.Single(i => i.LastName == "Jimerson").ID, OfficeLocation = "Seattle" }, new Location { RecruiterID = recruiters.Single(i => i.LastName == "Kimerson").ID, OfficeLocation = "Washington D.C." } }; context.Locations.AddRange(locations); context.SaveChanges(); var companyRecruiters = new CompanyAssignment[] { new CompanyAssignment { CompanyID = companies.Single(c => c.CompanyName == "Microsoft").CompanyID, RecruiterID = recruiters.Single(i => i.LastName == "Jimerson").ID }, new CompanyAssignment { CompanyID = companies.Single(c => c.CompanyName == "Amazon").CompanyID, RecruiterID = recruiters.Single(i => i.LastName == "Kimerson").ID }, }; context.CompanyAssignments.AddRange(companyRecruiters); context.SaveChanges(); var tags = new Tag[] { new Tag { JobID = 1, CompanyID = companies.Single(c => c.CompanyName == "Amazon").CompanyID }, new Tag { JobID = 2, CompanyID = companies.Single(c => c.CompanyName == "Amazon").CompanyID }, new Tag { JobID = 3, CompanyID = companies.Single(c => c.CompanyName == "Amazon").CompanyID }, new Tag { JobID = 4, CompanyID = companies.Single(c => c.CompanyName == "Microsoft").CompanyID } }; context.Tags.AddRange(tags); context.SaveChanges(); foreach (Tag t in tags) { var tagInDataBase = context.Tags.Where(s => s.Job.ID == t.JobID && s.Company.CompanyID == t.CompanyID).SingleOrDefault(); if (tagInDataBase == null) { context.Tags.Add(t); } } context.SaveChanges(); }
public Recruiter AddRecruiter(Recruiter newPosting) { return(_RecruiterRepository.AddRecruiter(newPosting)); }
public virtual async Task CreateRecruiterAsync(Recruiter recruiter) { recruiter.Validate(); await _recruiterRepository.UpsertAsync(recruiter); }
public Recruiter UpdateRecruiter(Recruiter updatedJob) { return(_RecruiterRepository.UpdateRecruiter(updatedJob)); }
public async Task <bool> UpdateEmployerProfile(EmployerProfileViewModel employer, string updaterId, string role) { try { if (employer.Id != null) { switch (role) { case "employer": Employer existingEmployer = (await _employerRepository.GetByIdAsync(employer.Id)); existingEmployer.CompanyContact = employer.CompanyContact; existingEmployer.PrimaryContact = employer.PrimaryContact; existingEmployer.ProfilePhoto = employer.ProfilePhoto; existingEmployer.ProfilePhotoUrl = employer.ProfilePhotoUrl; existingEmployer.DisplayProfile = employer.DisplayProfile; existingEmployer.UpdatedBy = updaterId; existingEmployer.UpdatedOn = DateTime.Now; var newSkills = new List <UserSkill>(); foreach (var item in employer.Skills) { var skill = existingEmployer.Skills.SingleOrDefault(x => x.Id == item.Id); if (skill == null) { skill = new UserSkill { Id = ObjectId.GenerateNewId().ToString(), IsDeleted = false }; } UpdateSkillFromView(item, skill); newSkills.Add(skill); } existingEmployer.Skills = newSkills; await _employerRepository.Update(existingEmployer); break; case "recruiter": Recruiter existingRecruiter = (await _recruiterRepository.GetByIdAsync(employer.Id)); existingRecruiter.CompanyContact = employer.CompanyContact; existingRecruiter.PrimaryContact = employer.PrimaryContact; existingRecruiter.ProfilePhoto = employer.ProfilePhoto; existingRecruiter.ProfilePhotoUrl = employer.ProfilePhotoUrl; existingRecruiter.DisplayProfile = employer.DisplayProfile; existingRecruiter.UpdatedBy = updaterId; existingRecruiter.UpdatedOn = DateTime.Now; var newRSkills = new List <UserSkill>(); foreach (var item in employer.Skills) { var skill = existingRecruiter.Skills.SingleOrDefault(x => x.Id == item.Id); if (skill == null) { skill = new UserSkill { Id = ObjectId.GenerateNewId().ToString(), IsDeleted = false }; } UpdateSkillFromView(item, skill); newRSkills.Add(skill); } existingRecruiter.Skills = newRSkills; await _recruiterRepository.Update(existingRecruiter); break; } return(true); } return(false); } catch (MongoException e) { return(false); } }
public async Task<ActionResult> Register([Bind(Include = "UserName, Password, ConfirmPassword, Email, FullName, PhoneNumber, RoleName")]RegisterViewModel model, string returnUrl) { UnitOfWork unitOfWork = new UnitOfWork(); AspNetUser u = unitOfWork.AspNetUserRepository.Get(s => s.UserName == model.UserName).FirstOrDefault(); if (u != null) { TempData["warningmessage"] = "Username đã tồn tại, xin hãy dùng Username khác!"; if (!String.IsNullOrEmpty(returnUrl)) { return Redirect("../" + returnUrl); } else { return RedirectToAction("Index", "Home"); } } Jobseeker js = accountUnitOfWork.JobseekerRepository.Get(s => s.Email == model.Email).FirstOrDefault(); Recruiter rc = accountUnitOfWork.RecruiterRepository.Get(s => s.Email == model.Email).FirstOrDefault(); if (js != null || rc != null) { TempData["warningmessage"] = "Email đã tồn tại, xin hãy dùng Email khác!"; if (!String.IsNullOrEmpty(returnUrl)) { return Redirect("../" + returnUrl); } else { return RedirectToAction("Index", "Home"); } } var user = new ApplicationUser() { UserName = model.UserName }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var createdUser = await UserManager.FindAsync(model.UserName, model.Password); var roleResult = await UserManager.AddToRoleAsync(createdUser.Id, model.RoleName); if (model.RoleName == "Recruiter") { Recruiter recruiter = new Recruiter(); recruiter.RecruiterID = createdUser.Id; recruiter.Email = model.Email; recruiter.IsDeleted = false; unitOfWork.RecruiterRepository.Insert(recruiter); unitOfWork.Save(); await SignInAsync(user, isPersistent: false); TempData["warningmessage"] = "Đăng ký thành công, xin hãy cập nhật thông tin công ty!"; return RedirectToAction("Update", "CompanyInfo"); } else { Jobseeker jobseeker = new Jobseeker(); jobseeker.JobSeekerID = createdUser.Id; jobseeker.Email = model.Email; jobseeker.FullName = model.FullName; jobseeker.PhoneNumber = model.PhoneNumber; jobseeker.IsDeleted = false; unitOfWork.JobseekerRepository.Insert(jobseeker); unitOfWork.Save(); await SignInAsync(user, isPersistent: false); TempData["successmessage"] = "Đăng ký thành công."; if (!String.IsNullOrEmpty(returnUrl)) { return Redirect("../" + returnUrl); } else { return RedirectToAction("Index", "Home"); } } } else { TempData["errormessage"] = "Đăng ký thất bại!"; if (!String.IsNullOrEmpty(returnUrl)) { return Redirect("../" + returnUrl); } else { return RedirectToAction("Index", "Home"); } } }