public async Task <bool> Delete(int companyId, int mentorId, int serialNumber)
{
ExternalMentorContact contact = await _context.ExternalMentorContacts
.FirstOrDefaultAsync(x => x.SerialNumber == serialNumber);
if (contact == null)
{
return(false);
}
_context.ExternalMentorContacts.Remove(contact);
await _context.SaveChangesAsync();
return(true);
}
public async Task <bool> Insert(Position position)
{
try
{
_context.Positions.Add(position);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>" + ex.Message);
return(false);
}
}
public async Task <bool> Insert(ExternalMentor mentor)
{
try
{
_context.ExternalMentors.Add(mentor);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>>>>>>>" + ex.Message);
return(false);
}
}
public async Task <bool> ChangePassword(string companyUsername, string newPassword)
{
try
{
var company = await _context.Companies.FirstOrDefaultAsync(x => x.CompanyUsername == companyUsername);
if (company == null)
{
return(false);
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(newPassword, out passwordHash, out passwordSalt);
company.PasswordHash = passwordHash;
company.PasswordSalt = passwordSalt;
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>>>>> " + ex.Message);
return(false);
}
}
public async Task <bool> Insert(ProjectProposal projectProposal)
{
try
{
var company = await _context.Companies
.FirstOrDefaultAsync(x => x.CompanyID == projectProposal.Company.CompanyID);
if (company == null)
{
return(false);
}
projectProposal.Company = company;
if (projectProposal.ExternalMentor.MentorID != 0)
{
var externalMentor = await _context.ExternalMentors.Include(c => c.Contacts)
.Where(x => x.CompanyID == projectProposal.ExternalMentor.CompanyID &&
x.MentorID == projectProposal.ExternalMentor.MentorID).FirstOrDefaultAsync();
var exMen = projectProposal.ExternalMentor;
if (externalMentor != null)
{
projectProposal.ExternalMentor = externalMentor;
}
foreach (var contact in exMen.Contacts)
{
if (contact.SerialNumber == 0)
{
projectProposal.ExternalMentor.Contacts.Add(contact);
}
}
}
foreach (var subj in projectProposal.Subjects)
{
var pom = await _context.ScientificAreas
.FirstOrDefaultAsync(x => x.ScientificAreaID == subj.ScientificArea.ScientificAreaID);
if (pom == null)
{
return(false);
}
subj.ScientificArea = pom;
}
projectProposal.ProposalDate = DateTime.Now;
await _context.ProjectProposals.AddAsync(projectProposal);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>>>> " + ex.Message);
return(false);
}
}
public async Task <bool> Delete(Project project)
{
try
{
var projectForDelete = await _context.Projects
.FirstOrDefaultAsync(x => x.ProjectID == project.ProjectID);
if (projectForDelete == null)
{
return(false);
}
_context.Projects.Remove(projectForDelete);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>>>> " + ex.Message);
return(false);
}
}
public async Task <bool> Delete(long companyId, long cityId)
{
try
{
var locationToRemove = await _context.Locations
.FirstOrDefaultAsync(x => x.CompanyID == companyId && x.CityID == cityId);
if (locationToRemove == null)
{
return(false);
}
_context.Locations.Remove(locationToRemove);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>> " + ex.Message);
return(false);
}
}
public async Task <bool> Delete(Contact contact)
{
try
{
var contactFromRepo = await _context.Contacts
.FirstOrDefaultAsync(x => x.CompanyID == contact.CompanyID && x.ContactID == contact.ContactID);
if (contactFromRepo == null)
{
return(false);
}
_context.Contacts.Remove(contactFromRepo);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>>>" + ex);
return(false);
}
}
public async Task <Employee> Register(Employee employee, string password)
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
employee.PasswordHash = passwordHash;
employee.PasswordSalt = passwordSalt;
//await _context.Employees.AddAsync(employee);
await _context.SaveChangesAsync();
return(employee);
}
public async Task <bool> Insert(Company company, string password)
{
try
{
foreach (var location in company.Locations)
{
location.City = await _context.Cities.FirstOrDefaultAsync(x => x.CityID == location.City.CityID);
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
company.PasswordHash = passwordHash;
company.PasswordSalt = passwordSalt;
await _context.Companies.AddAsync(company);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>>>>> " + ex.Message);
return(false);
}
}
public async Task <bool> Insert(ProjectContract projectContract)
{
try
{
var project = await _context.Projects
.FirstOrDefaultAsync(x => x.ProjectID == projectContract.Project.ProjectID);
if (project == null)
{
return(false);
}
projectContract.Project = project;
var employee = await _context.Employees
.FirstOrDefaultAsync(x => x.EmployeeID == projectContract.InternalSigner.EmployeeID);
if (employee == null)
{
return(false);
}
projectContract.InternalSigner = employee;
if (projectContract.SigningDate == null ||
string.IsNullOrWhiteSpace(projectContract.CompanySigner) ||
projectContract.ExpiryDate == null)
{
return(false);
}
await _context.ProjectContracts.AddAsync(projectContract);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>>>>> " + ex.Message);
return(false);
}
}
