public async Task SavePost(PostModel postModel, int userId)
{
await using (_context = new Sep3DBContext())
{
PostModel databasePostModel = await _context.Posts
.FirstAsync(p => p.Id == postModel.Id);
AccountModel accountModel = await _context.Accounts
.Include(acc => acc.SavedPosts)
.FirstAsync(a => a.UserId == userId);
if (accountModel.SavedPosts == null)
{
accountModel.SavedPosts = new List <AccountSavedPost>();
}
AccountSavedPost accountSavedPost = new AccountSavedPost()
{
AccountId = accountModel.UserId,
AccountModel = accountModel,
SavedPostId = databasePostModel.Id,
SavedPostModel = databasePostModel
};
accountModel.SavedPosts.Add(accountSavedPost);
_context.Accounts.Update(accountModel);
await _context.SaveChangesAsync();
}
}
public async Task CreateComponentRating(RatingComponentModel ratingComponentModel)
{
await using (_context = new Sep3DBContext())
{
bool exists = await _context.RatingComponent.AnyAsync(r =>
r.AccountModelUserId == ratingComponentModel.AccountModelUserId &&
r.ComponentModelId == ratingComponentModel.ComponentModelId);
if (exists)
{
List <RatingComponentModel> list = await _context.RatingComponent
.Where(r => r.ComponentModelId == ratingComponentModel.ComponentModelId &&
r.AccountModelUserId == ratingComponentModel.AccountModelUserId).ToListAsync();
RatingComponentModel rating = list[0];
rating.Score = ratingComponentModel.Score;
_context.RatingComponent.Update(rating);
await _context.SaveChangesAsync();
}
else
{
Console.WriteLine("rating nu exista ");
await _context.RatingComponent.AddAsync(ratingComponentModel);
await _context.SaveChangesAsync();
}
}
}
public async Task <AccountModel> GetAccountById(int userId)
{
await using (_context = new Sep3DBContext())
{
AccountModel accountModel = await _context.Accounts
.Include(acc => acc.Posts)
.ThenInclude(p => p.Ratings)
.Include(acc => acc.Posts)
.ThenInclude(p => p.Comments)
.Include(a => a.Builds)
.Include(a => a.Comments)
.Include(a => a.Reports)
.Include(a => a.SavedPosts)
.FirstAsync(a => a.UserId == userId);
foreach (var user in _context.AccountFollowedAccounts)
{
if (user.AccountModelUserId == userId)
{
accountModel.FollowedAccounts.Add(user.FollowedAccountModel);
}
}
return(accountModel);
}
}
public async Task DeleteAccount(int userId)
{
await using (_context = new Sep3DBContext())
{
AccountModel accountModel = await _context.Accounts
.Include(a => a.Builds)
.ThenInclude(b => b.BuildComponents)
.Include(acc => acc.Posts)
.ThenInclude(p => p.Comments)
.FirstAsync(account => account.UserId == userId);
foreach (var build in accountModel.Builds)
{
build.BuildComponents = new Collection <BuildComponent>();
}
foreach (var post in accountModel.Posts)
{
post.Comments = new Collection <CommentModel>();
}
foreach (var variable in _context.AccountFollowedAccounts)
{
if (variable.AccountModelUserId == userId)
{
_context.AccountFollowedAccounts.Remove(variable);
}
}
accountModel.Builds = new Collection <BuildModel>();
accountModel.Posts = new Collection <PostModel>();
_context.Accounts.Remove(accountModel);
await _context.SaveChangesAsync();
}
}
public async Task <string> CreateAccount(AccountModel accountModel)
{
await using (_context = new Sep3DBContext())
{
foreach (var variable in _context.Accounts)
{
if (variable.Username.Equals(accountModel.Username))
{
Console.WriteLine("Account already exists");
return("Account already exists");
}
}
accountModel.Builds = new List <BuildModel>();
accountModel.Comments = new List <CommentModel>();
accountModel.Posts = new List <PostModel>();
accountModel.BuildRatings = new List <RatingBuildModel>();
accountModel.PostRatings = new List <RatingPostModel>();
accountModel.ComponentRatings = new List <RatingComponentModel>();
accountModel.SavedPosts = new List <AccountSavedPost>();
accountModel.FollowedAccounts = new List <AccountModel>();
await _context.Accounts.AddAsync(accountModel);
Console.WriteLine("Account successfully created");
await _context.SaveChangesAsync();
}
return("Account successfully created");
}
public async Task EditBuild(BuildModel buildModel)
{
await using (_context = new Sep3DBContext())
{
BuildModel buildModelDatabase = await _context.Builds
.Include(b => b.BuildComponents)
.FirstAsync(bld => bld.Id == buildModel.Id);
buildModelDatabase.Name = buildModel.Name;
buildModelDatabase.BuildComponents = new Collection <BuildComponent>();
for (var i = 0; i < buildModel.ComponentList.Count(); i++)
{
ComponentModel arg = await _context.Components
.FirstAsync(c => c.Id == buildModel.ComponentList[i].Id);
BuildComponent buildComponent = new BuildComponent
{
BuildId = buildModelDatabase.Id,
BuildModel = buildModelDatabase,
ComponentId = arg.Id,
ComponentModel = arg
};
buildModelDatabase.BuildComponents.Add(buildComponent);
}
_context.Update(buildModelDatabase);
await _context.SaveChangesAsync();
}
}
public async Task EditComponent(ComponentModel componentModel)
{
await using (_context = new Sep3DBContext())
{
_context.Components.Update(componentModel);
await _context.SaveChangesAsync();
}
}
public async Task <ComponentModel> GetComponentByName(string name)
{
await using (_context = new Sep3DBContext())
{
return(await _context.Components
.FirstAsync(c => c.Name == name));
}
}
public async Task EditPost(PostModel postModel)
{
await using (_context = new Sep3DBContext())
{
_context.Posts.Update(postModel);
await _context.SaveChangesAsync();
}
}
public async Task <IList <ComponentModel> > GetFilteredList(string type)
{
await using (_context = new Sep3DBContext())
{
return(await _context.Components
.Include(c => c.Ratings)
.Where(c => c.Type.Equals(type)).ToListAsync());
}
}
public async Task <IList <ComponentModel> > GetComponents()
{
await using (_context = new Sep3DBContext())
{
return(await _context.Components
.Include(c => c.Ratings)
.ToListAsync());
}
}
public async Task <PostModel> GetPost(int postId)
{
await using (_context = new Sep3DBContext())
{
return(await _context.Posts
.Include(post => post.Comments)
.FirstAsync(p => p.Id == postId));
}
}
public async Task <ComponentModel> GetComponentById(int componentId)
{
await using (_context = new Sep3DBContext())
{
return(await _context.Components
.Include(c => c.Ratings)
.FirstAsync(c => c.Id == componentId));
}
}
public async Task <IList <RatingBuildModel> > GetAllBuildRatings(int buildId)
{
await using (_context = new Sep3DBContext())
{
IList <RatingBuildModel> ratings = await _context.RatingBuild
.Where(r => r.BuildModelId == buildId).ToListAsync();
return(ratings);
}
}
public async Task <IList <RatingComponentModel> > GetAllComponentRatings(int componentId)
{
await using (_context = new Sep3DBContext())
{
IList <RatingComponentModel> ratings = await _context.RatingComponent
.Where(r => r.ComponentModelId == componentId).ToListAsync();
return(ratings);
}
}
public async Task CreateComponent(ComponentModel componentModel)
{
await using (_context = new Sep3DBContext())
{
componentModel.Ratings = new Collection <RatingComponentModel>();
await _context.Components.AddAsync(componentModel);
await _context.SaveChangesAsync();
}
}
public async Task <IList <RatingPostModel> > GetAllPostRatings(int postId)
{
await using (_context = new Sep3DBContext())
{
IList <RatingPostModel> ratings = await _context.RatingPost
.Where(r => r.PostModelId == postId).ToListAsync();
return(ratings);
}
}
public async Task DeleteReport(int reportId)
{
await using (_context = new Sep3DBContext())
{
ReportModel reportModel = await _context.Reports
.FirstAsync(r => r.Id == reportId);
_context.Reports.Remove(reportModel);
await _context.SaveChangesAsync();
}
}
public async Task <IList <PostModel> > GetAllPosts()
{
await using (_context = new Sep3DBContext())
{
List <PostModel> posts = await _context.Posts
.Include(p => p.Comments)
.Include(post => post.Ratings).ToListAsync();
return(posts);
}
}
public async Task <AccountModel> GetAccountByUsername(string username)
{
await using (_context = new Sep3DBContext())
{
AccountModel accountModel = await _context.Accounts
.Include(acc => acc.Posts)
.FirstAsync(a => a.Username.Equals(username));
return(accountModel);
}
}
public async Task <BuildModel> GetBuild(int buildId)
{
await using (_context = new Sep3DBContext())
{
return(await _context.Builds
.Include(b => b.BuildComponents)
.ThenInclude(bld => bld.ComponentModel)
.Include(c => c.Ratings)
.Include(r => r.Ratings)
.FirstAsync(build => build.Id == buildId));
}
}
public async Task RemoveComponentFromBuild(int buildId, int componentId)
{
await using (_context = new Sep3DBContext())
{
BuildComponent buildComponent = _context.Builds
.Where(b => b.Id == buildId)
.SelectMany(build => build.BuildComponents)
.First(build => build.ComponentModel.Id == componentId);
_context.Remove(buildComponent);
Console.WriteLine("removed component");
await _context.SaveChangesAsync();
}
}
public async Task DeleteComponent(int componentId)
{
await using (_context = new Sep3DBContext())
{
ComponentModel component = await _context.Components
.Include(c => c.Ratings)
.Include(c => c.BuildComponents)
.FirstAsync(c => c.Id == componentId);
_context.Components.Remove(component);
await _context.SaveChangesAsync();
}
}
public async Task DeleteBuild(int buildId)
{
await using (_context = new Sep3DBContext())
{
BuildModel buildModel = await _context.Builds
.Include(b => b.BuildComponents)
.Include(r => r.Ratings)
.FirstAsync(build => build.Id == buildId);
buildModel.BuildComponents = new Collection <BuildComponent>();
_context.Builds.Remove(buildModel);
await _context.SaveChangesAsync();
}
}
public async Task CreateReport(ReportModel reportModel)
{
await using (_context = new Sep3DBContext())
{
PostModel postModel = await _context.Posts
.Include(post => post.Reports)
.FirstAsync(p => p.Id == reportModel.PostModelId);
postModel.Reports.Add(reportModel);
_context.Posts.Update(postModel);
await _context.Reports.AddAsync(reportModel);
await _context.SaveChangesAsync();
}
}
public async Task <AccountModel> GetAccount(string username, string password)
{
try
{
await using (_context = new Sep3DBContext())
{
return(_context.Accounts
.First(a => a.Username.Equals(username) && a.Password.Equals(password)));
}
}
catch (Exception e)
{
Console.WriteLine("Account does not exist");
}
return(null);
}
public async Task <IList <ReportModel> > ReadAllReports()
{
await using (_context = new Sep3DBContext())
{
List <ReportModel> reports = await _context.Reports.ToListAsync();
foreach (var report in reports)
{
AccountModel accountModel = await _context.Accounts.FirstAsync(a => a.UserId == report.AccountModelId);
report.Username = accountModel.Username;
Console.WriteLine(report.Username);
}
return(reports);
}
}
public async Task <IList <CommentModel> > GetCommentsFromPost(int postId)
{
await using (_context = new Sep3DBContext())
{
PostModel post = await _context.Posts
.Include(p => p.Comments)
.FirstAsync(pst => pst.Id == postId);
Console.WriteLine(post + " took post from database to get comments from");
IList <CommentModel> commentList = new List <CommentModel>();
foreach (var comment in post.Comments)
{
commentList.Add(comment);
}
return(commentList);
}
}
public async Task <IList <PostModel> > GetPostsFromAccount(int userId)
{
await using (_context = new Sep3DBContext())
{
AccountModel account = _context.Accounts
.Include(acc => acc.Posts)
.First(a => a.UserId == userId);
Console.WriteLine(account + " took from database to get posts from");
IList <PostModel> postList = new List <PostModel>();
foreach (var post in account.Posts)
{
postList.Add(post);
Console.WriteLine(post.ToString());
}
return(postList);
}
}
public async Task CreateBuild(BuildModel buildModel)
{
await using (_context = new Sep3DBContext())
{
buildModel.Ratings = new List <RatingBuildModel>();
await _context.Builds.AddAsync(buildModel);
await _context.SaveChangesAsync();
AccountModel accountModel = await _context.Accounts
.Include(a => a.Builds)
.FirstAsync(account => account.UserId == buildModel.AccountModelUserId);
BuildModel databaseBuild = await _context.Builds.OrderBy(b => b.Id).LastAsync();
if (accountModel.Builds == null)
{
accountModel.Builds = new List <BuildModel>();
}
accountModel.Builds.Add(databaseBuild);
_context.Update(accountModel);
if (databaseBuild.BuildComponents == null)
{
databaseBuild.BuildComponents = new List <BuildComponent>();
}
for (var i = 0; i < databaseBuild.ComponentList.Count; i++)
{
ComponentModel arg = await _context.Components.FirstAsync(c => c.Id == databaseBuild.ComponentList[i].Id);
BuildComponent buildComponent = new BuildComponent
{
BuildId = databaseBuild.Id,
BuildModel = databaseBuild,
ComponentId = arg.Id,
ComponentModel = arg
};
databaseBuild.BuildComponents.Add(buildComponent);
}
_context.Update(databaseBuild);
await _context.SaveChangesAsync();
}
}
