public void LoadLanguages()
{
//Load languages for a project with this Id
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
//Instantiate the language list
this.Languages = new LanguageList();
var ProjectLanguages = (from pl in dc.tblProjectLanguages
join l in dc.tblLanguages on pl.LanguageId equals l.Id
where pl.ProjectId == this.Id
select new
{
l.Id,
l.Description
}).ToList();
foreach (var language in ProjectLanguages)
{
Language lang = new Language();
lang.Id = language.Id;
lang.Description = language.Description;
this.Languages.Add(lang);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public int Delete()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
tblProject project = dc.tblProjects.Where(p => p.Id == Id).FirstOrDefault();
if (project != null)
{
ProjectLanguageList pll = new ProjectLanguageList();
pll.LoadByProjectId(project.Id);
foreach (ProjectLanguage pl in pll)
{
pl.Delete();
}
dc.tblProjects.Remove(project);
return(dc.SaveChanges());
}
else
{
throw new Exception("Project not found");
}
}
}
catch (Exception ex) { throw ex; }
}
public void LoadById(Guid id)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var portfolioProject = (from pp in dc.tblPortfolioProjects
join pr in dc.tblProjects on pp.ProjectId equals pr.Id
join po in dc.tblPortfolios on pp.PortfolioId equals po.Id
where pp.Id == id
select new
{
pp.Id,
pp.PortfolioId,
pp.ProjectId,
ProjectName = pr.Name,
PortfolioName = po.Name
}).FirstOrDefault();
if (portfolioProject != null)
{
Id = portfolioProject.Id;
PortfolioId = portfolioProject.PortfolioId;
ProjectId = portfolioProject.ProjectId;
ProjectName = portfolioProject.ProjectName;
PortfolioName = portfolioProject.PortfolioName;
}
else
{
throw new Exception("Portfolio Project not found");
}
}
}
catch (Exception ex) { throw ex; }
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseMvc();
using (var context = new PortfolioEntities())
{
context.Database.EnsureCreated();
if (context.Projects.Count() == 0)
{
context.Seed(context);
}
}
}
public void LoadbyProjectID(Guid id)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var screenshots = (from s in dc.tblScreenshots
join p in dc.tblProjects on s.ProjectId equals p.Id
join u in dc.tblUsers on p.UserId equals u.Id
//join pr in dc.tblPrivacies on p.PrivacyId equals pr.Id
where p.Id == id || id == null
select new
{
s.Id,
s.Filepath,
s.ProjectId,
p.Name
// p.PrivacyId,
// Privacy = pr.Description,
}).OrderByDescending(p => p.Id).ToList();
foreach (var s in screenshots)
{
Screenshot screenshot = new Screenshot(s.Id, s.Filepath, s.ProjectId, s.Name);
Add(screenshot);
}
}
}
catch (Exception ex) { throw ex; }
}
public void Load()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var screenshots = (from s in dc.tblScreenshots
join p in dc.tblProjects on s.ProjectId equals p.Id
//where s.ProjectId == id || id == null
select new
{
s.Id,
s.Filepath,
s.ProjectId,
p.Name
}).OrderByDescending(p => p.Filepath).ToList();
foreach (var s in screenshots)
{
Screenshot screenshot = new Screenshot(s.Id, s.Filepath, s.ProjectId, s.Name);
Add(screenshot);
}
}
}
catch (Exception ex) { throw ex; }
}
public void Load()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var portfolios = (from p in dc.tblPortfolios
join pr in dc.tblPrivacies on p.PrivacyId equals pr.Id
join u in dc.tblUsers on p.UserId equals u.Id
//where p.UserId == id || id == null
select new
{
p.Id,
p.Name,
p.Description,
p.PortfolioImage,
p.UserId,
p.PrivacyId,
Privacy = pr.Description,
u.Email
}).OrderByDescending(p => p.Name).ToList();
foreach (var p in portfolios)
{
Portfolio portfolio = new Portfolio(p.Id, p.Name, p.Description, p.PortfolioImage, p.UserId, p.Email, p.Privacy, p.PrivacyId);
portfolio.LoadProjectsInPortFolio();
Add(portfolio);
}
}
}
catch (Exception ex) { throw ex; }
}
public void LoadById(Guid id)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var screenshot = (from s in dc.tblScreenshots
join p in dc.tblProjects on s.ProjectId equals p.Id
where s.Id == id
select new
{
s.Id,
s.Filepath,
s.ProjectId,
p.Name
}).FirstOrDefault();
if (screenshot != null)
{
Id = screenshot.Id;
FilePath = screenshot.Filepath;
ProjectId = screenshot.ProjectId;
ProjectName = screenshot.Name;
}
else
{
throw new Exception("Screenshot not found");
}
}
}
catch (Exception ex) { throw ex; }
}
public int Update()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
tblPortfolio portfolio = dc.tblPortfolios.Where(p => p.Id == Id).FirstOrDefault();
if (portfolio != null)
{
portfolio.Name = Name;
portfolio.Description = Description;
portfolio.PrivacyId = PrivacyId;
portfolio.PortfolioImage = PortfolioImage;
portfolio.UserId = UserId;
return(dc.SaveChanges());
}
else
{
throw new Exception("Portfolio not found");
}
}
}
catch (Exception ex) { throw ex; }
}
/// <summary>
/// Loads Projects in a Portfolio (should also load languages in Project)
/// </summary>
public void LoadProjectsInPortFolio()
{
//Load Projects for a portfolio with portfolio ojbects Id
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
//Instantiate the Projects list
this.Projects = new ProjectList();
var PortfolioProjects = (from pp in dc.tblPortfolioProjects
join p in dc.tblProjects on pp.ProjectId equals p.Id
where pp.PortfolioId == this.Id
select new
{
p.Id
}).ToList();
foreach (var project in PortfolioProjects)
{
//Instantiate Project
Project proj = new Project();
// Load Project (this should also populate languages in project then)
proj.LoadById(project.Id);
// Add Project to Projects
this.Projects.Add(proj);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Insert project into portfolio
/// </summary>
/// <param name="projectId"> Id of Project to add to Portfolio object </param>
/// <returns> bool for success status </returns>
public bool AddProject(Guid projectId)
{
try
{
Project project = new Project();
project.LoadById(projectId);
Portfolio port = new Portfolio();
ProjectList prjs = new ProjectList();
prjs = port.LoadProjects(port.Id);
foreach (Project prj in prjs)
{
if (prj.Name == project.Name)
{
// Already exists in Portfolio
return(false); //this should probably be a throw ex
}
}
using (PortfolioEntities dc = new PortfolioEntities())
{
tblPortfolio portfolio = dc.tblPortfolios.Where(p => p.Id == Id).FirstOrDefault();
tblPortfolioProject portProj = new tblPortfolioProject()
{
Id = Guid.NewGuid(),
ProjectId = projectId,
PortfolioId = portfolio.Id
};
dc.tblPortfolioProjects.Add(portProj);
dc.SaveChanges();
}
return(true);
}
catch (Exception ex) { throw ex; }
}
public void LoadById(Guid id)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var projectlanguage = (from pl in dc.tblProjectLanguages
//join lang in dc.tblLanguages on pl.LanguageId equals lang.Id
//join p in dc.tblProjects on pl.ProjectId equals p.Id
where pl.Id == id
select new
{
pl.Id,
pl.ProjectId,
pl.LanguageId
}).FirstOrDefault();
if (projectlanguage != null)
{
Id = projectlanguage.Id;
ProjectId = projectlanguage.ProjectId;
LanguageId = projectlanguage.LanguageId;
}
else
{
throw new Exception("ProjectLanguage not found");
}
}
}
catch (Exception ex) { throw ex; }
}
/// <summary>
/// Loads ProjectLanguageList by a partial Language description (name)
/// </summary>
/// <param name="PartialLanguageName"> The description (name) of the Language as string</param>
public void LoadByPartialLanguageName(string PartialLanguageName)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var projectlanguages = (from pl in dc.tblProjectLanguages
join lang in dc.tblLanguages on pl.LanguageId equals lang.Id
join p in dc.tblProjects on pl.ProjectId equals p.Id
where lang.Description.Contains(PartialLanguageName) || PartialLanguageName == null
select new
{
pl.Id,
pl.ProjectId,
pl.LanguageId
}).OrderByDescending(pl => pl.Id).ToList();
foreach (var pl in projectlanguages)
{
ProjectLanguage projectlanguage = new ProjectLanguage(pl.Id, pl.ProjectId, pl.LanguageId);
Add(projectlanguage);
}
}
}
catch (Exception ex) { throw ex; }
}
// Inserts project without portfolio
public void Insert(Guid userId)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
tblProject project = new tblProject()
{
Id = Guid.NewGuid(),
Name = Name,
Location = Location,
Filepath = Filepath,
PrivacyId = PrivacyId,
Image = Image,
Description = Description,
UserId = userId,
DateCreated = DateCreated,
Purpose = Purpose,
Environment = Environment,
Challenges = Challenges,
FuturePlans = FuturePlans,
Collaborators = Collaborators,
LastUpdated = LastUpdated,
SoftwareUsed = SoftwareUsed,
StatusId = StatusId
};
dc.tblProjects.Add(project);
dc.SaveChanges();
}
}
catch (Exception ex) { throw ex; }
}
public void Load()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var portfolioProjects = (from p in dc.tblPortfolioProjects
join pr in dc.tblProjects on p.ProjectId equals pr.Id
join po in dc.tblPortfolios on p.PortfolioId equals po.Id
select new
{
p.Id,
p.PortfolioId,
p.ProjectId,
ProjectName = pr.Name,
PortfolioName = po.Name
}).ToList();
foreach (var p in portfolioProjects)
{
PortfolioProject portfolioProject = new PortfolioProject(p.Id, p.PortfolioId, p.ProjectId, p.PortfolioName, p.ProjectName);
Add(portfolioProject);
}
}
}
catch (Exception ex) { throw ex; }
}
public void LoadByUserId(Guid id)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var fg = (from f in dc.tblForgotPasswords
join u in dc.tblUsers on f.UserId equals u.Id
where u.Id == id
select new
{
f.Id,
f.ExpirationDate,
f.UserId,
}).FirstOrDefault();
if (fg != null)
{
Id = fg.Id;
ExpirationDate = fg.ExpirationDate;
UserId = fg.UserId;
}
else
{
throw new Exception("Reset Link not found");
}
}
}
catch (Exception ex) { throw ex; }
}
public void Load()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var users = (from u in dc.tblUsers
join ut in dc.tblUserTypes on u.UserTypeId equals ut.Id
select new
{
u.Id,
u.Email,
u.Password,
u.FirstName,
u.LastName,
u.ProfileImage,
u.UserTypeId,
u.Username,
u.Bio,
ut.Description
}).OrderByDescending(u => u.LastName).ToList();
foreach (var u in users)
{
User user = new User(u.Id, u.Email, u.Password, u.FirstName, u.LastName, u.ProfileImage, u.UserTypeId, u.Description, u.Username, u.Bio);
Add(user);
}
}
}
catch (Exception ex) { throw ex; }
}
/// <summary>
/// Loads UserList by a partial User's Username as a string
///
/// DOESNT LOAD PROJECTS OR PORTFOLIOS CURRENTLY FOR EACH USER
///
/// </summary>
/// <param name="PartialUserName"> The partial Username of the User as string </param>
public void LoadByPartialUserName(string PartialUserName)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var users = (from u in dc.tblUsers
join ut in dc.tblUserTypes on u.UserTypeId equals ut.Id
where u.Username.Contains(PartialUserName) || PartialUserName == null
select new
{
u.Id,
u.Email,
u.Password,
u.FirstName,
u.LastName,
u.ProfileImage,
u.UserTypeId,
u.Username,
u.Bio,
ut.Description
}).OrderByDescending(u => u.LastName).ToList();
foreach (var u in users)
{
User user = new User(u.Id, u.Email, u.Password, u.FirstName, u.LastName, u.ProfileImage, u.UserTypeId, u.Description, u.Username, u.Bio);
//POSSIBLY ADD LOAD PROJECTS AND LOAD PORTFOLIOS HERE
Add(user);
}
}
}
catch (Exception ex) { throw ex; }
}
// Standard Update Method
public int Update()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
// Password is done in seperate Passwordupdate Method
tblUser user = dc.tblUsers.Where(u => u.Id == Id).FirstOrDefault();
if (user != null)
{
user.Email = Email;
user.FirstName = FirstName;
user.LastName = LastName;
user.ProfileImage = ProfileImage;
user.UserTypeId = UserTypeId;
user.Username = Username;
user.Bio = Bio;
return(dc.SaveChanges());
}
else
{
throw new Exception("User not found");
}
}
}
catch (Exception ex) { throw ex; }
}
// Change Password from Forgot password key
public int ChangeForgottenPassword(string password)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
tblForgotPassword forgottenpass = dc.tblForgotPasswords.Where(u => u.UserId == Id).FirstOrDefault();
if ((DateTime.Now) < (forgottenpass.ExpirationDate))
{
// Current time is earlier than expiration date of reset link
tblUser user = dc.tblUsers.Where(u => u.Id == Id).FirstOrDefault();
if (user != null)
{
// User exists
user.Password = GetHash(password, user.Id);
return(dc.SaveChanges());
}
else
{
throw new Exception("User not found");
}
}
else
{
throw new Exception("Password Reset Link Expired");
}
}
}
catch (Exception ex) { throw ex; }
}
//------------------- START STANDARD INSERT UPDATE DELETE METHODS ---------------------
// Standard Insert Method
public int Insert()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
Guid userId = Guid.NewGuid();
tblUser user = new tblUser()
{
Id = userId,
Email = Email,
Password = GetHash(this.Password, userId),
FirstName = FirstName,
LastName = LastName,
ProfileImage = ProfileImage,
UserTypeId = UserTypeId,
Username = Username,
Bio = Bio
};
//Save the Id
this.Id = user.Id;
dc.tblUsers.Add(user);
return(dc.SaveChanges());
}
}
catch (Exception ex) { throw ex; }
}
//------------------- END CONSTRUCTORS ---------------------
#endregion Constructors
#region User Password
//------------------- START PASSWORD METHODS ---------------------
// Update Password
public int UpdatePassword(string password, string oldpassword, Guid userId)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
tblUser user = dc.tblUsers.Where(u => u.Id == Id).FirstOrDefault();
if (user != null)
{
if (user.Password == GetHash(oldpassword, user.Id))
{
user.Password = GetHash(password, user.Id);
return(dc.SaveChanges());
}
else
{
throw new Exception("Incorrect Password");
}
}
else
{
throw new Exception("User not found");
}
}
}
catch (Exception ex) { throw ex; }
}
public void InsertTest()
{
using (PortfolioEntities dc = new PortfolioEntities())
{
//Create a user
tblUser user = new tblUser
{
//User a GUID for testing purposes
Id = Guid.Parse("11112222-3333-4444-5555-666677778888"),
Email = "*****@*****.**",
Password = "******",
FirstName = "Test",
LastName = "Test",
ProfileImage = "Test.Test",
UserTypeId = Guid.NewGuid()
};
//Add the user to the database
dc.tblUsers.Add(user);
//Commit changes
int rowsInserted = dc.SaveChanges();
Assert.IsTrue(rowsInserted == 1);
}
}
public int ClearForgottenPasswordsByUser(tblUser user)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var links = (from link in dc.tblForgotPasswords
join u in dc.tblUsers on link.UserId equals u.Id
where link.UserId == user.Id
select new
{
link.Id,
link.UserId,
link.ExpirationDate
}).ToList();
foreach (var link in links)
{
tblForgotPassword forgottenpass = dc.tblForgotPasswords.Where(p => p.Id == link.Id).FirstOrDefault();
forgottenpass.Id = link.Id;
forgottenpass.ExpirationDate = link.ExpirationDate;
forgottenpass.UserId = link.UserId;
dc.tblForgotPasswords.Remove(forgottenpass);
}
return(dc.SaveChanges());
}
}
catch (Exception ex)
{
throw ex;
}
}
public void LoadByLanguageID(Guid?id)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var projectlanguages = (from pl in dc.tblProjectLanguages
join lang in dc.tblLanguages on pl.LanguageId equals lang.Id
join p in dc.tblProjects on pl.ProjectId equals p.Id
where pl.LanguageId == id || id == null
select new
{
pl.Id,
pl.ProjectId,
pl.LanguageId
}).OrderByDescending(pl => pl.Id).ToList();
foreach (var pl in projectlanguages)
{
ProjectLanguage projectlanguage = new ProjectLanguage(pl.Id, pl.ProjectId, pl.LanguageId);
Add(projectlanguage);
}
}
}
catch (Exception ex) { throw ex; }
}
public void LoadTest()
{
using (PortfolioEntities dc = new PortfolioEntities())
{
//Ensure that at least 1 row is loaded from the database
Assert.IsTrue(dc.tblStatuses.Count() > 0);
}
}
public void LoadById()
{
using (PortfolioEntities dc = new PortfolioEntities())
{
//This is Test guid from CreateNewProject (all string inputs are "111", user is joe@wetzel)
Guid projectGuid = Guid.Parse("797c8d2b-d1ba-4bba-825d-eb28bab26cf8");
tblProject project = dc.tblProjects.FirstOrDefault(p => p.Id == projectGuid);
Assert.AreEqual("111", project.Description);
}
}
//------------------- END STANDARD INSERT UPDATE DELETE METHODS ---------------------
#endregion Standard Insert Update Delete
#region Checking Existance
//------------------- START CHECKING EXISTANCE METHODS METHODS ---------------------
public bool CheckIfEmailExists(string email)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
bool exists = dc.tblUsers.Any(u => u.Email == email);
return(exists);
}
}
catch (Exception ex) { throw ex; }
}
public void LoadbyPortfolioID(Guid id)
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var projects = (from p in dc.tblProjects
join pr in dc.tblPrivacies on p.PrivacyId equals pr.Id
join u in dc.tblUsers on p.UserId equals u.Id
join pp in dc.tblPortfolioProjects on p.Id equals pp.ProjectId
join pf in dc.tblPortfolios on pp.PortfolioId equals pf.Id
join s in dc.tblStatuses on p.StatusId equals s.Id
where pf.Id == id || pf.Id == null
select new
{
p.Id,
p.Name,
p.Location,
p.Filepath,
p.PrivacyId,
p.Image,
p.Description,
p.UserId,
p.DateCreated,
p.Purpose,
p.Environment,
p.Challenges,
p.FuturePlans,
p.Collaborators,
p.LastUpdated,
p.SoftwareUsed,
p.StatusId,
Privacy = pr.Description,
Status = s.Description,
UserEmail = u.Email
}).OrderByDescending(p => p.LastUpdated).ToList();
foreach (var p in projects)
{
Project project = new Project(p.Id, p.Name, p.Location, p.Filepath, p.PrivacyId, p.Image, p.Description, p.UserId, p.DateCreated, p.Purpose,
p.Environment, p.Challenges, p.FuturePlans, p.Collaborators, p.LastUpdated, p.SoftwareUsed, p.StatusId, p.Privacy, p.Status, p.UserEmail);
//Load languages on the project
project.LoadLanguages();
Add(project);
}
}
}
catch (Exception ex) { throw ex; }
}
public void Load()
{
try
{
using (PortfolioEntities dc = new PortfolioEntities())
{
var userTypes = dc.tblUserTypes.OrderBy(ut => ut.Description);
foreach (var ut in userTypes)
{
UserType userType = new UserType(ut.Id, ut.Description);
Add(userType);
}
}
}
catch (Exception ex) { throw ex; }
}
