public async Task<bool> Register(ArgJobSeekerTemp arg) { Utils.CheckNullOrEmpty(new List<string> { "Email", "FullName", "PhoneNumber" }, arg.Email, arg.FullName, arg.PhoneNumber); using (AppDbContext context = new AppDbContext()) { if (arg.Industry==null) { arg.Industry = await context.Industries.FirstOrDefaultAsync(x => x.Name == null); } context.JobSeekerTempProfiles.Add(new JobSeekerTempProfile { FullName = arg.FullName, Email = arg.Email, PhoneNumber = arg.PhoneNumber, ExperienceLevel = arg.ExperienceLevel, IndustryId = arg.Industry.Id, DayOfBirthUtc = arg.DayOfBirthUtc, RegisteredDateUtc = DateTime.UtcNow }); await EmailDelivery.SendJobSeekerRegisterCompleted(arg.Email); await context.SaveChangesAsync(); return true; } }
public async Task<User> GetEmployerById(Guid id) { using (AppDbContext context = new AppDbContext()) { User user = await context.Users.Include(x => x.Employer).Where(x => x.Id == id).FirstOrDefaultAsync(); return user; } }
public async Task<List<CompanyHisotry>> GetCompanyHistoryForJobSeeker(Guid id) { using (AppDbContext context = new AppDbContext()) { List<CompanyHisotry> companyHisotries = await context.CompanyHisotries.Where(x => x.JobSeekerId == id).OrderBy(x=>x.CreatedDateUtc).ToListAsync(); return companyHisotries; } }
public async Task<List<User>> GetTopEmployer() { using (AppDbContext context = new AppDbContext()) { List<User> users = await context.Users.Include(x => x.Employer).Where(x => x.UserType == UserType.Employer).OrderByDescending(x => x.Employer.CreatedDateUtc).Take(5).ToListAsync(); return users; } }
public async Task CreateNewJob(CreateEditJobParams createEditJobParams) { Utils.CheckNullOrEmpty(new List<string> { "JobName", "JobType", "JobDescription", "EducationLevel", "FieldOfStudy", "Language", "Certification", "MinimumGrade", "IsStartWorkImmediately", "ExperienceLevel", "StartWorkingAt", "EndWorkingAt", "StartDate", "HoursPerDay", "DayPerWeek", "DayPerMonth", "GenderRequired", "MinSalary", "MaxSalary", "IsSalaryIncludeMealAndBreakTime" }, createEditJobParams.JobName, createEditJobParams.JobType, createEditJobParams.JobDescription, createEditJobParams.Location, createEditJobParams.EducationLevel, createEditJobParams.FieldOfStudy, createEditJobParams.Language, createEditJobParams.Certification, createEditJobParams.MinimumGrade, createEditJobParams.IsStartWorkImmediately, createEditJobParams.ExperienceLevel, createEditJobParams.StartWorkingAt, createEditJobParams.EndWorkingAt, createEditJobParams.StartDate, createEditJobParams.HoursPerDay, createEditJobParams.DayPerWeek, createEditJobParams.DayPerMonth, createEditJobParams.GenderRequired, createEditJobParams.MinSalary, createEditJobParams.MaxSalary, createEditJobParams.IsSalaryIncludeMealAndBreakTime); using (AppDbContext context = new AppDbContext()) { User user = await GetCurrentUser(context); if (user.UserType == UserType.Employer) { Job job = new Job { Id = Guid.NewGuid(), EmployerId = _userId, LanguageId = createEditJobParams.Language.Id, JobName = createEditJobParams.JobName, JobType = createEditJobParams.JobType, MinSalary = createEditJobParams.MinSalary, MaxSalary = createEditJobParams.MaxSalary, ExtraSalary = createEditJobParams.ExtraSalary, StartDate = createEditJobParams.StartDate, EndDate = createEditJobParams.EndDate, JobStartDate = createEditJobParams.JobStartDate, JobDescription = createEditJobParams.JobDescription, IsStartWorkImmediately = createEditJobParams.IsStartWorkImmediately, StartWorkingAt = createEditJobParams.StartWorkingAt, EndWorkingAt = createEditJobParams.EndWorkingAt, AvailableDate = DateTime.UtcNow, HoursPerDay = createEditJobParams.HoursPerDay, DayPerWeek = createEditJobParams.DayPerWeek, DayPerMonth = createEditJobParams.DayPerMonth, GenderRequired = createEditJobParams.GenderRequired, IsSalaryIncludeMealAndBreakTime = createEditJobParams.IsSalaryIncludeMealAndBreakTime, CreatedDateUtc = DateTime.UtcNow, UpdatedDateUtc = DateTime.UtcNow, LocationId = createEditJobParams.Location.Id }; context.Jobs.Add(job); Education education = new Education { Id = Guid.NewGuid(), EducationLevel = createEditJobParams.EducationLevel, FieldOfStudyId = createEditJobParams.FieldOfStudy.Id, Certification = createEditJobParams.Certification, MinimumGrade = createEditJobParams.MinimumGrade, ExperienceLevel = createEditJobParams.ExperienceLevel, JobId = job.Id }; context.Educations.Add(education); await context.SaveChangesAsync(); } else { throw new UserException(ErrorCode.NO_PERMISSION.ToString()); } } }
public async Task<User> GetUser(Guid id) { using (AppDbContext context = new AppDbContext()) { await GetCurrentUser(context); User user = await context.Users.Include(x => x.JobSeeker).Include(x => x.Employer).Include(x => x.JobSeeker.Language).FirstOrDefaultAsync(p => p.Id == id); return user; } }
public async Task<List<CompanyHisotry>> GetCompanytHistory(Guid id) { using (AppDbContext context = new AppDbContext()) { await GetCurrentUser(context); List<CompanyHisotry> companyHisotries = await context.CompanyHisotries.Where(x => x.JobSeekerId == id).ToListAsync(); return companyHisotries; } }
public async Task<User> Login(LoginParams loginParams) { Utils.CheckNullOrEmpty(new List<string> { "Email", "Token" }, loginParams.Email, loginParams.Token); using (AppDbContext context = new AppDbContext()) { User user = await context.Users.FirstOrDefaultAsync(p => p.Email == loginParams.Email && p.AccountType == loginParams.AccountType && p.UserType == loginParams.UserType); if (user == null) { throw new UserException(ErrorCode.INVALID.ToString()); } if (!user.IsActivated) { throw new UserException(ErrorCode.USER_NOT_VERIFIED_YET.ToString()); } if (loginParams.AccountType == AccountType.Email) { if (!UtilsCryptography.VerifyBCryptPassword(loginParams.Token, user.Password)) { throw new UserException(ErrorCode.INVALID.ToString()); } } else if (loginParams.AccountType == AccountType.Facebook) { try { FacebookClient facebookClient = new FacebookClient(loginParams.Token); await facebookClient.GetTaskAsync("me?fields=id"); } catch (Exception) { throw new UserException(ErrorCode.FACEBOOK_INVALID.ToString()); } } else { try { string query = "https://www.googleapis.com/oauth2/v1/userinfo?access_token=" + loginParams.Token; HttpClient client = new HttpClient(); await client.GetStringAsync(query); } catch (Exception) { throw new UserException(ErrorCode.GOOGLE_INVALID.ToString()); } } return user; } }
public async Task<bool> CheckEmail(ArgJobSeekerTemp arg) { Utils.CheckNullOrEmpty(new List<string> { "Email" }, arg.Email); using (AppDbContext context = new AppDbContext()) { JobSeekerTempProfile jobSeekerTempProfile = await context.JobSeekerTempProfiles.FirstOrDefaultAsync(x => x.Email == arg.Email); return jobSeekerTempProfile == null; } }
protected async Task<User> GetCurrentUser(AppDbContext context) { User user = await context.Users.FirstOrDefaultAsync(p => p.Id == _userId); if (user == null) { throw new UserException(ErrorCode.INVALID_SESSION.ToString()); } return user; }
public async Task<JobSeeker> CreateTempFile(Guid id) { using (AppDbContext context = new AppDbContext()) { JobSeeker jobSeeker = await context.JobSeekers.FirstOrDefaultAsync(x => x.UserId == id); if (jobSeeker == null) { throw new UserException(ErrorCode.FILE_NOT_FOUND.ToString()); } return jobSeeker; } }
public async Task DeleteCompanyHistory(CompanyHisotry deleteCompanyHisotry) { using (AppDbContext context = new AppDbContext()) { CompanyHisotry companyHisotry =await context.CompanyHisotries.Where(x => x.Id == deleteCompanyHisotry.Id).FirstOrDefaultAsync(); if (companyHisotry == null) { throw new UserException(ErrorCode.INVALID.ToString()); } context.CompanyHisotries.Remove(companyHisotry); await context.SaveChangesAsync(); } }
public async Task UpdateEmployerLogoPhoto(byte[] imageBytes) { using (AppDbContext context = new AppDbContext()) { User user = await GetCurrentUser(context); if (user.UserType == UserType.Employer) { Employer employer = await context.Employers.FirstOrDefaultAsync(x => x.UserId == user.Id); employer.Logo = imageBytes; await context.SaveChangesAsync(); } } }
public async Task UpdateJobSeekerProfilePhoto(byte[] imageBytes) { using (AppDbContext context = new AppDbContext()) { User user = await GetCurrentUser(context); if (user.UserType == UserType.JobSeeker) { JobSeeker jobSeeker = await context.JobSeekers.FirstOrDefaultAsync(x => x.UserId == user.Id); jobSeeker.Avartar = imageBytes; await context.SaveChangesAsync(); } } }
public async Task UpdateJobSeekerMoreDoc(byte[] imageBytes,string extension) { using (AppDbContext context = new AppDbContext()) { User user = await GetCurrentUser(context); if (user.UserType == UserType.JobSeeker) { JobSeeker jobSeeker = await context.JobSeekers.FirstOrDefaultAsync(x => x.UserId == user.Id); jobSeeker.MoreDocument = imageBytes; jobSeeker.Extension = extension; await context.SaveChangesAsync(); } } }
public async Task UpdateJob(CreateEditJobParams createEditJobParams) { Utils.CheckNullOrEmpty(new List<string> { "JobId", "JobName", "JobType", "JobDescription", "EducationLevel", "FieldOfStudy", "Language", "Certification", "MinimumGrade", "IsStartWorkImmediately", "ExperienceLevel", "StartWorkingAt", "EndWorkingAt", "StartDate", "HoursPerDay", "DayPerWeek", "DayPerMonth", "GenderRequired", "MinSalary", "MaxSalary", "IsSalaryIncludeMealAndBreakTime" }, createEditJobParams.JobID, createEditJobParams.JobName, createEditJobParams.JobType, createEditJobParams.JobDescription, createEditJobParams.Location, createEditJobParams.EducationLevel, createEditJobParams.FieldOfStudy, createEditJobParams.Language, createEditJobParams.Certification, createEditJobParams.MinimumGrade, createEditJobParams.IsStartWorkImmediately, createEditJobParams.ExperienceLevel, createEditJobParams.StartWorkingAt, createEditJobParams.EndWorkingAt, createEditJobParams.StartDate, createEditJobParams.HoursPerDay, createEditJobParams.DayPerWeek, createEditJobParams.DayPerMonth, createEditJobParams.GenderRequired, createEditJobParams.MinSalary, createEditJobParams.MaxSalary, createEditJobParams.IsSalaryIncludeMealAndBreakTime); using (AppDbContext context = new AppDbContext()) { Job job = await context.Jobs.FirstOrDefaultAsync(p => p.Id == createEditJobParams.JobID); Education education = await context.Educations.FirstOrDefaultAsync(p => p.JobId == createEditJobParams.JobID); if (job == null || education == null) { throw new UserException(ErrorCode.INVALID_SESSION.ToString()); } job.LanguageId = createEditJobParams.Language.Id; job.JobName = createEditJobParams.JobName; job.JobType = createEditJobParams.JobType; job.MinSalary = createEditJobParams.MinSalary; job.MaxSalary = createEditJobParams.MaxSalary; job.ExtraSalary = createEditJobParams.ExtraSalary; job.StartDate = createEditJobParams.StartDate; job.EndDate = createEditJobParams.EndDate; job.JobStartDate = createEditJobParams.JobStartDate; job.JobDescription = createEditJobParams.JobDescription; job.IsStartWorkImmediately = createEditJobParams.IsStartWorkImmediately; job.StartWorkingAt = createEditJobParams.StartWorkingAt; job.EndWorkingAt = createEditJobParams.EndWorkingAt; job.HoursPerDay = createEditJobParams.HoursPerDay; job.DayPerWeek = createEditJobParams.DayPerWeek; job.DayPerMonth = createEditJobParams.DayPerMonth; job.GenderRequired = createEditJobParams.GenderRequired; job.IsSalaryIncludeMealAndBreakTime = createEditJobParams.IsSalaryIncludeMealAndBreakTime; job.UpdatedDateUtc = DateTime.UtcNow; job.LocationId = createEditJobParams.Location.Id; education.EducationLevel = createEditJobParams.EducationLevel; education.FieldOfStudyId = createEditJobParams.FieldOfStudy.Id; education.Certification = createEditJobParams.Certification; education.MinimumGrade = createEditJobParams.MinimumGrade; education.ExperienceLevel = createEditJobParams.ExperienceLevel; await context.SaveChangesAsync(); } }
public async Task Feedback (FeedbackParams feedbackParams) { Utils.CheckNullOrEmpty(new List<string> { "FullName", "Address", "Email", "PhoneNumber", "Message" }, feedbackParams.FullName, feedbackParams.Address, feedbackParams.Email, feedbackParams.PhoneNumber, feedbackParams.Message); using (AppDbContext context = new AppDbContext()) { Feedback feedback = new Feedback { Id = Guid.NewGuid(), FullName = feedbackParams.FullName, Address = feedbackParams.Address, Email = feedbackParams.Email, PhoneNumber = feedbackParams.PhoneNumber, Message = feedbackParams.Message, CreatedDateUtc = DateTime.UtcNow }; context.Feedbacks.Add(feedback); await context.SaveChangesAsync(); } }
public async Task<Tuple<List<User>, int, int>> Search(SearchEmployerParams employerParams) { using (AppDbContext context = new AppDbContext()) { var query = context.Users.Include(x => x.Employer).Where(x => x.UserType == UserType.Employer).AsQueryable(); if (!string.IsNullOrWhiteSpace(employerParams.CompanyName)) { query = query.Where(x => x.Employer.CompanyName == employerParams.CompanyName); } int totalItems = await query.CountAsync(); int totalPages = totalItems / employerParams.PageSize; if (totalItems % employerParams.PageSize > 0) { totalPages++; } List<User> users = await query.OrderByDescending(p => p.Employer.CompanyName).Skip(employerParams.PageIndex * employerParams.PageSize).Take(employerParams.PageSize).ToListAsync(); return new Tuple<List<User>, int, int>(users, totalPages, totalItems); } }
public async Task<List<Location>> GetAllLocation() { using (AppDbContext context = new AppDbContext()) { List<Location> locations = await context.Locations.OrderBy(x => x.Name).ToListAsync(); return locations; } }
public async Task UpdateEmployerProfile(EmployerProfileUpdatedCompanyInfoParams employerProfileUpdatedCompanyInfoParams) { Utils.CheckNullOrEmpty(new List<string> { "UserId", "CompanyName", "CompanyRegistrationNumber", "Address", "WebLink", "ContactName", "PhoneNumber", "NatureOfBusiness" }, employerProfileUpdatedCompanyInfoParams.UserId, employerProfileUpdatedCompanyInfoParams.CompanyName, employerProfileUpdatedCompanyInfoParams.CompanyRegistrationNumber, employerProfileUpdatedCompanyInfoParams.Address, employerProfileUpdatedCompanyInfoParams.WebLink, employerProfileUpdatedCompanyInfoParams.ContactName, employerProfileUpdatedCompanyInfoParams.PhoneNumber, employerProfileUpdatedCompanyInfoParams.NatureOfBusiness); using (AppDbContext context = new AppDbContext()) { User user = await context.Users.FirstOrDefaultAsync(p => p.Id == employerProfileUpdatedCompanyInfoParams.UserId); Employer employer = await context.Employers.FirstOrDefaultAsync(p => p.UserId == employerProfileUpdatedCompanyInfoParams.UserId); if (employer == null || user == null) { throw new UserException(ErrorCode.INVALID_SESSION.ToString()); } employer.CompanyName = employerProfileUpdatedCompanyInfoParams.CompanyName; employer.CompanyRegistrationNumber = employerProfileUpdatedCompanyInfoParams.CompanyRegistrationNumber; employer.Address = employerProfileUpdatedCompanyInfoParams.Address; employer.WebLink = employerProfileUpdatedCompanyInfoParams.WebLink; employer.ContactName = employerProfileUpdatedCompanyInfoParams.ContactName; employer.PhoneNumber = employerProfileUpdatedCompanyInfoParams.PhoneNumber; employer.NatureOfBusiness = employerProfileUpdatedCompanyInfoParams.NatureOfBusiness; await context.SaveChangesAsync(); } }
public async Task UpdateEmployerProfile(EmployerProfileUpdatedOverviewParams employerProfileUpdatedOverviewParams) { using (AppDbContext context = new AppDbContext()) { Employer employer = await context.Employers.FirstOrDefaultAsync(p => p.UserId == employerProfileUpdatedOverviewParams.UserId); if (employer == null) { throw new UserException(ErrorCode.INVALID_SESSION.ToString()); } employer.OverView = employerProfileUpdatedOverviewParams.OverView; await context.SaveChangesAsync(); } }
public async Task UpdateJobSeekerProfile(JobSeekerProfileUpdatedExperienceLevelParams param) { Utils.CheckNullOrEmpty(new List<string> { "ExperienceYear", "HighestEducation", "ExpectedPosition", "ExpectedLocation", "ExpectedJobCategory", "ExpectedSalary", "UserId" }, param.ExperienceYear, param.HighestEducation, param.ExpectedPosition, param.ExpectedLocation, param.ExpectedJobCategory, param.ExpectedSalary, param.UserId); using (AppDbContext context = new AppDbContext()) { User user = await context.Users.FirstOrDefaultAsync(p => p.Id == param.UserId); JobSeeker jobSeeker = await context.JobSeekers.FirstOrDefaultAsync(p => p.UserId == param.UserId); if (jobSeeker == null || user == null) { throw new UserException(ErrorCode.INVALID_SESSION.ToString()); } jobSeeker.ExperienceYear = param.ExperienceYear; jobSeeker.HighestEducation = param.HighestEducation; jobSeeker.ExpectedPosition = param.ExpectedPosition; jobSeeker.ExpectedLocation = param.ExpectedLocation; jobSeeker.ExpectedJobCategory = param.ExpectedJobCategory; jobSeeker.ExpectedSalary = param.ExpectedSalary; jobSeeker.CanNegotiation = param.CanNegotiation; jobSeeker.LanguageId = param.Language.Id; jobSeeker.UpdatedDateUtc = DateTime.UtcNow; foreach (CompanyHisotry companyHistory in param.CompanyHistories) { var company = await context.CompanyHisotries.FirstOrDefaultAsync(x => x.Id == companyHistory.Id); if (company == null) { var newItem = new CompanyHisotry { JobSeekerId = jobSeeker.UserId, CompanyName = companyHistory.CompanyName, Position = companyHistory.Position, From = companyHistory.From, To = companyHistory.To, CreatedDateUtc = DateTime.UtcNow, UpdatedDateUtc = DateTime.UtcNow }; context.CompanyHisotries.Add(newItem); } else { company.CompanyName = companyHistory.CompanyName; company.Position = companyHistory.Position; company.From = companyHistory.From; company.To = companyHistory.To; company.UpdatedDateUtc = DateTime.UtcNow; } } await context.SaveChangesAsync(); } }
public async Task UpdateJobSeekerProfile(JobSeekerProfileUpdatedAdditionInfoParam param) { using (AppDbContext context = new AppDbContext()) { JobSeeker jobSeeker = await context.JobSeekers.FirstOrDefaultAsync(p => p.UserId == param.UserId); if (jobSeeker == null) { throw new UserException(ErrorCode.INVALID_SESSION.ToString()); } jobSeeker.AdditionalInfo = param.AdditionalInfo; jobSeeker.UpdatedDateUtc = DateTime.UtcNow; await context.SaveChangesAsync(); } }
public async Task ChangePassword(ChangePasswordParams changePasswordParams) { Utils.CheckNullOrEmpty(new List<string> { "CurrentPassword", "NewPassword" }, changePasswordParams.CurrentPassword, changePasswordParams.NewPassword); using (AppDbContext context = new AppDbContext()) { User user = await context.Users.FirstOrDefaultAsync(p => p.Id == changePasswordParams.UserId); if (user == null) { throw new UserException(ErrorCode.INVALID.ToString()); } if (!UtilsCryptography.VerifyBCryptPassword(changePasswordParams.CurrentPassword, user.Password)) { throw new UserException(ErrorCode.CURRENT_PASSWORD_INCORRECT.ToString()); } user.Password = UtilsCryptography.GenerateBCryptHash(changePasswordParams.NewPassword); await context.SaveChangesAsync(); } }
//job seeker profile public async Task UpdateJobSeekerProfile(JobSeekerProfileUpdatedPersonalInfoParams param) { Utils.CheckNullOrEmpty(new List<string> { "DateOfBirth", "Email", "FullName", "Gender", "NRICNumber", "NRICType", "NationalServiceStatus", "UserId", "PostalCode", "PhoneNumber" }, param.DateOfBirth, param.Email, param.FullName, param.Gender, param.NRICNumber, param.NRICType, param.NationalServiceStatus, param.UserId, param.PostalCode, param.PhoneNumber); using (AppDbContext context = new AppDbContext()) { User user = await context.Users.FirstOrDefaultAsync(p => p.Id == param.UserId); JobSeeker jobSeeker = await context.JobSeekers.FirstOrDefaultAsync(p => p.UserId == param.UserId); if (jobSeeker == null || user == null) { throw new UserException(ErrorCode.INVALID_SESSION.ToString()); } user.Email = param.Email; jobSeeker.FullName = param.FullName; jobSeeker.Gender = param.Gender; jobSeeker.NationalServiceStatus = param.NationalServiceStatus; jobSeeker.DateOfBirth = param.DateOfBirth; jobSeeker.NRICNumber = param.NRICNumber; jobSeeker.NRICType = param.NRICType; jobSeeker.Race = param.Race; jobSeeker.Religions = param.Religions; jobSeeker.PhoneNumber = param.PhoneNumber; jobSeeker.MobileNumber = param.MobileNumber; jobSeeker.PostalCode = param.PostalCode; jobSeeker.Address = param.Address; jobSeeker.UpdatedDateUtc = DateTime.UtcNow; await context.SaveChangesAsync(); } }
public async Task ResetPassword(ResetPasswordParams resetPasswordParams) { Utils.CheckNullOrEmpty(new List<string> { "ConfirmationCode", "Password" }, resetPasswordParams.ConfirmationCode, resetPasswordParams.Password); using (AppDbContext context = new AppDbContext()) { User user = await context.Users.FirstOrDefaultAsync(p => p.ConfirmationCode == resetPasswordParams.ConfirmationCode); if (user == null) { throw new UserException(ErrorCode.INVALID.ToString()); } user.ConfirmationCode = null; user.Password = UtilsCryptography.GenerateBCryptHash(resetPasswordParams.Password); await context.SaveChangesAsync(); } }
public async Task ForgotPassword(string email) { Utils.CheckNullOrEmpty(new List<string> { "Email" }, email); using (AppDbContext context = new AppDbContext()) { User user = await context.Users.FirstOrDefaultAsync(p => p.Email == email); if (user == null) { throw new UserException(ErrorCode.EMAIL_INVALID.ToString()); } user.ConfirmationCode = Guid.NewGuid().ToString(); await context.SaveChangesAsync(); await EmailDelivery.SendForgotPasswordRequest(email, user.ConfirmationCode); } }
public async Task<User> RegisterJobseeker(RegisterJobseekerParams registerJobseekerParams) { Utils.CheckNullOrEmpty(new List<string> { "Email", "Token", "AccountType" }, registerJobseekerParams.Email, registerJobseekerParams.Token, registerJobseekerParams.AccountType); if (!Utils.IsEmail(registerJobseekerParams.Email)) { throw new UserException(ErrorCode.EMAIL_INVALID.ToString()); } using (AppDbContext context = new AppDbContext()) { if (await context.Users.AnyAsync(p => p.Email == registerJobseekerParams.Email)) { throw new UserException(ErrorCode.EMAIL_IN_USED.ToString()); } byte[] imageBytes = null; bool activated = true; string confirmationCode = string.Empty; if (registerJobseekerParams.AccountType == AccountType.Email) { activated = false; confirmationCode = Guid.NewGuid().ToString(); registerJobseekerParams.Token = UtilsCryptography.GenerateBCryptHash(registerJobseekerParams.Token); } else if (registerJobseekerParams.AccountType == AccountType.Facebook) { try { FacebookClient facebookClient = new FacebookClient(registerJobseekerParams.Token); await facebookClient.GetTaskAsync("me?fields=id"); WebClient webClient = new WebClient(); imageBytes = webClient.DownloadData(registerJobseekerParams.AvatarPath); registerJobseekerParams.Token = null; } catch (Exception) { throw new UserException(ErrorCode.FACEBOOK_INVALID.ToString()); } } else { try { string query = "https://www.googleapis.com/oauth2/v1/userinfo?access_token=" + registerJobseekerParams.Token; HttpClient client = new HttpClient(); await client.GetStringAsync(query); WebClient webClient = new WebClient(); imageBytes = webClient.DownloadData(registerJobseekerParams.AvatarPath); registerJobseekerParams.Token = null; } catch (Exception) { throw new UserException(ErrorCode.GOOGLE_INVALID.ToString()); } } User user = new User { Id = Guid.NewGuid(), Email = registerJobseekerParams.Email, Password = registerJobseekerParams.Token, AccountType = registerJobseekerParams.AccountType, UserType = UserType.JobSeeker, RegisteredDateUtc = DateTime.UtcNow, IsActivated = activated, ConfirmationCode = confirmationCode }; context.Users.Add(user); Language defaultLanguage = await context.Languages.FirstOrDefaultAsync(p => p.Name == "English - United States"); if (registerJobseekerParams.AccountType != AccountType.Email) { registerJobseekerParams.DayOfBirthUtc = new DateTime(2000, 1, 1); registerJobseekerParams.NRICType = NRICType.Citizen; } JobSeeker jobSeeker = new JobSeeker { UserId = user.Id, Avartar = imageBytes, FullName = registerJobseekerParams.FullName, Gender = Gender.Male, NRICNumber = registerJobseekerParams.NRICNumber, DateOfBirth = registerJobseekerParams.DayOfBirthUtc, NRICType = registerJobseekerParams.NRICType, ExperienceYear = ExperienceYear.Student, LanguageId = defaultLanguage.Id, CanNegotiation = true, CreatedDateUtc = DateTime.UtcNow, UpdatedDateUtc = DateTime.UtcNow }; context.JobSeekers.Add(jobSeeker); await context.SaveChangesAsync(); if (user.IsActivated) { await EmailDelivery.SendJobSeekerRegisterCompleted(registerJobseekerParams.Email); } else { await EmailDelivery.SendJobSeekerRegisterActivation(registerJobseekerParams.Email, confirmationCode); return null; } return user; } }
public async Task<User> ActiveJobSeekerAccount(string code) { Utils.CheckNullOrEmpty(new List<string> { "Activation Code" }, code); using (AppDbContext context = new AppDbContext()) { User user = await context.Users.FirstOrDefaultAsync(p => p.ConfirmationCode == code && p.IsActivated == false); if (user == null) { throw new UserException(ErrorCode.INVALID.ToString()); } user.IsActivated = true; user.ConfirmationCode = null; await context.SaveChangesAsync(); return user; } }
public async Task<bool> RegisterEmployer(RegisterEmployerParam registerEmployerParam) { if (!Utils.IsEmail(registerEmployerParam.Email)) { throw new UserException(ErrorCode.EMAIL_INVALID.ToString()); } using (AppDbContext context = new AppDbContext()) { if (await context.Users.AnyAsync(p => p.Email == registerEmployerParam.Email)) { throw new UserException(ErrorCode.EMAIL_IN_USED.ToString()); } Random generator = new Random(); string password = generator.Next(100000, 999999).ToString(); User user = new User { Id = Guid.NewGuid(), Email = registerEmployerParam.Email, Password = UtilsCryptography.GenerateBCryptHash(password), AccountType = AccountType.Email, UserType = UserType.Employer, RegisteredDateUtc = DateTime.UtcNow, IsActivated = true, ConfirmationCode = "" }; context.Users.Add(user); Employer employer = new Employer { CompanyName = registerEmployerParam.CompanyName, CompanyRegistrationNumber = registerEmployerParam.CompanyRegistrationNumber, ContactName = registerEmployerParam.ContactName, PhoneNumber = registerEmployerParam.ContactNumber, NatureOfBusiness = registerEmployerParam.NaturalOfBusiness, OverView = registerEmployerParam.Message, CreatedDateUtc = DateTime.UtcNow, UpdatedDateUtc = DateTime.UtcNow, UserId = user.Id, }; context.Employers.Add(employer); await context.SaveChangesAsync(); await EmailDelivery.SendEmployerRegisterCompleted(registerEmployerParam.Email, password); return true; } }