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");
}
}
}
