private List <User> GetUsers()
{
using (var _context = new CrossRefContext())
{
return(_context.Users.Where(x => x.Id != GetUserId()).ToList());
}
}
private List <int> GetCollaboratorsIds()
{
using (var _context = new CrossRefContext())
{
return(_context.Collaborators.Where(x => x.AuthorId == GetUserId()).Select(x => x.CollaboratorId).ToList());
}
}
public IActionResult Search(SearchViewModel model)
{
var individualNames = model.ResearcherName.Split(" ");
if (individualNames.Length != 2)
{
return(RedirectToAction("UserList", "UserList", false));
}
var firstName = individualNames[0];
var lastName = individualNames[1];
using (var db = new CrossRefContext())
{
var candidateUser = db.Users.FirstOrDefault(u =>
u.FirstName.Equals(firstName, StringComparison.InvariantCultureIgnoreCase) &&
u.LastName.Equals(lastName, StringComparison.InvariantCultureIgnoreCase) ||
u.FirstName.Equals(lastName, StringComparison.InvariantCultureIgnoreCase) &&
u.LastName.Equals(firstName, StringComparison.InvariantCultureIgnoreCase));
if (candidateUser == null)
{
return(RedirectToAction("UserList", "UserList", false));
}
return(RedirectToAction("Overview", "Profile", new { id = candidateUser.Id }));
}
}
private int GetUserId()
{
using (var _context = new CrossRefContext())
{
User user = _context.Users.First(u => u.Email.Equals(User.FindFirst(ClaimTypes.Email).Value));
return(user == null ? -1 : user.Id);
}
}
public IActionResult UserList(bool wrongSearch = false)
{
var userListViewModel = new UserListViewModel {
WrongSearch = wrongSearch
};
using (var db = new CrossRefContext())
{
var users = db.Users.Include("ArticleAuthors").Where(u => u.ArticleAuthors.Count > 0).ToList();
var userList = users.Select(user => Tuple.Create(user.FirstName + " " + user.LastName, user.Id)).ToList();
userListViewModel.Users = userList;
}
return(View(userListViewModel));
}
private async Task LoginAsync(string email)
{
using (var db = new CrossRefContext())
{
var user = db.Users.First(u => u.Email.Equals(email));
var claims = new[]
{
new Claim(ClaimTypes.Name, user.FirstName + " " + user.LastName),
new Claim(ClaimTypes.Email, user.Email)
};
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
await HttpContext.SignInAsync(principal);
}
}
public IActionResult Articles()
{
using (var db = new CrossRefContext())
{
var articleViewModel = new ArticlesViewModel();
var articles = db.Users
.Where(u => u.Email.Equals(
User.FindFirst(ClaimTypes.Email).Value))
.SelectMany(u => u.ArticleAuthors)
.Select(a => a.Article)
.ToList();
articleViewModel.Articles = articles;
return(View(articleViewModel));
}
}
private static bool AreCredentialsValid(string email, string password)
{
using (var db = new CrossRefContext())
{
if (!db.Users.Any(u => u.Email.Equals(email)))
{
return(false);
}
var user = db.Users.First(u => u.Email.Equals(email));
return(user.Password == Convert.ToBase64String(KeyDerivation.Pbkdf2(
password,
Encoding.ASCII.GetBytes("salt"),
KeyDerivationPrf.HMACSHA1,
10000,
256 / 8)));
}
}
public IActionResult Settings()
{
using (var db = new CrossRefContext())
{
var user = db.Users.First(u => u.Email.Equals(
User.FindFirst(ClaimTypes.Email).Value));
var settingsViewModel = new SettingsViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Biography = user.Biography,
DateOfBirth = user.DateOfBirth,
Affiliation = user.Affiliation
};
return(View(settingsViewModel));
}
}
public IActionResult Permissions(PermissionsViewModel permissionsViewModel)
{
using (var db = new CrossRefContext())
{
var user = db.Users.Include("Permission").First(u =>
u.Email.Equals(
User.FindFirst(ClaimTypes.Email).Value
));
user.Permission.ShowAffiliation = permissionsViewModel.ShowAffiliation;
user.Permission.ShowArticles = permissionsViewModel.ShowArticles;
user.Permission.ShowBiography = permissionsViewModel.ShowBiography;
user.Permission.ShowDateOfBirth = permissionsViewModel.ShowDateOfBirth;
db.Update(user);
db.SaveChanges();
return(RedirectToAction("MyOverview", "Profile"));
}
}
public IActionResult Permissions()
{
using (var db = new CrossRefContext())
{
var user = db.Users.Include("Permission").First(u =>
u.Email.Equals(
User.FindFirst(ClaimTypes.Email).Value
));
var permissionsViewModel = new PermissionsViewModel
{
ShowBiography = user.Permission.ShowBiography,
ShowAffiliation = user.Permission.ShowAffiliation,
ShowArticles = user.Permission.ShowArticles,
ShowDateOfBirth = user.Permission.ShowDateOfBirth
};
return(View(permissionsViewModel));
}
}
public IActionResult Overview(int id)
{
using (var db = new CrossRefContext())
{
if (!db.Users.Any(u => u.Id == id))
{
return(NotFound());
}
if (User.Identity.IsAuthenticated &&
User.FindFirst(ClaimTypes.Email).Value.Equals(db.Users.First(u => u.Id == id).Email))
{
return(View());
}
var profileViewModel = GenerateProfileViewModelForUser(id);
return(View(profileViewModel));
}
}
private static ProfileViewModel GenerateProfileViewModelForUser(int id)
{
using (var db = new CrossRefContext())
{
var user = db.Users.Include(u => u.Permission).First(u => u.Id == id);
var permission = user.Permission;
var profileViewModel = new ProfileViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
ShowArticles = permission.ShowArticles,
ShowBiography = permission.ShowBiography,
ShowAffiliation = permission.ShowAffiliation,
ShowDateOfBirth = permission.ShowDateOfBirth
};
if (profileViewModel.ShowArticles)
{
profileViewModel.Articles = db.Users.Where(u => u.Id == id).SelectMany(u => u.ArticleAuthors)
.Select(aa => aa.Article).ToList();
}
if (profileViewModel.ShowAffiliation)
{
profileViewModel.Affiliation = user.Affiliation;
}
if (profileViewModel.ShowBiography)
{
profileViewModel.Biography = user.Biography;
}
if (profileViewModel.ShowDateOfBirth)
{
profileViewModel.DateOfBirth = user.DateOfBirth;
}
return(profileViewModel);
}
}
public async Task <IActionResult> AddArticlePost(ArticleViewModel articleViewModel)
{
using (var _context = new CrossRefContext())
{
Article newPublication = new Article()
{
Title = articleViewModel.Title,
Published = articleViewModel.PublishedTime,
YearOfPublication = articleViewModel.PublishedTime.Year
};
List <ArticleAuthors> articleAuthors = new List <ArticleAuthors>();
articleAuthors.Add(new ArticleAuthors()
{
UserId = GetUserId(),
Article = newPublication
});
_context.Articles.Add(newPublication);
List <Collaborator> collaborators = new List <Collaborator>();
foreach (int id in articleViewModel.SelectedUserIds)
{
articleAuthors.Add(new ArticleAuthors()
{
UserId = id,
Article = newPublication
});
Collaborator collaborator = new Collaborator()
{
AuthorId = GetUserId(),
CollaboratorId = id
};
collaborators.Add(collaborator);
}
_context.Collaborators.AddRange(collaborators);
_context.ArticleAuthors.AddRange(articleAuthors);
await _context.SaveChangesAsync();
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> AddArticle()
{
using (var _context = new CrossRefContext())
{
var dbUsers = await _context
.Users
.Where(x => x.Id != GetUserId())
.OrderBy(x => x.FirstName)
.ToListAsync();
ArticleViewModel articleViewModel = new ArticleViewModel()
{
Users = dbUsers.Select(x => new SelectListItem
{
Text = $"{x.FirstName} {x.LastName}",
Value = x.Id.ToString()
}).ToList()
};
return(View(articleViewModel));
}
}
public IActionResult Register(RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
using (var db = new CrossRefContext())
{
if (db.Users.Any(u => u.Email.Equals(model.Email)))
{
ModelState.AddModelError("EmailAlreadyInUse", "Email address is already in use");
}
var user = new User
{
Email = model.Email,
Password = EncryptPassword(model.Password),
FirstName = model.FirstName,
LastName = model.LastName
};
var permission = new Permission
{
Author = user,
ShowArticles = false,
ShowBiography = false,
ShowAffiliation = false,
ShowDateOfBirth = false
};
db.Users.Add(user);
db.Permissions.Add(permission);
db.SaveChanges();
return(RedirectToAction("Login", "Authentication"));
}
}
public IActionResult Settings(SettingsViewModel settingsViewModel)
{
if (!ModelState.IsValid)
{
return(View(settingsViewModel));
}
using (var db = new CrossRefContext())
{
var user = db.Users.First(u => u.Email.Equals(
User.FindFirst(ClaimTypes.Email).Value));
user.FirstName = settingsViewModel.FirstName;
user.LastName = settingsViewModel.LastName;
user.Affiliation = settingsViewModel.Affiliation;
user.Biography = settingsViewModel.Biography;
user.DateOfBirth = settingsViewModel.DateOfBirth;
db.Update(user);
db.SaveChanges();
return(View("Overview"));
}
}
public async Task <IActionResult> FetchArticles()
{
using (var db = new CrossRefContext())
{
var user = db.Users.First(u => u.Email.Equals(
User.FindFirst(ClaimTypes.Email).Value));
var articles = await CrossRefService.FetchArticles(
user.FirstName + " " + user.LastName,
user.Affiliation);
foreach (var article in articles)
{
var existingArticle = db.Articles
.Include("ArticleAuthors")
.FirstOrDefault(a => a.DOI.Equals(article.DOI));
if (existingArticle != null)
{
if (existingArticle.ArticleAuthors.Any(aa => aa.UserId == user.Id))
{
continue;
}
var manyToManyBullshit = existingArticle.ArticleAuthors;
manyToManyBullshit.Add(new ArticleAuthors
{
User = user,
Article = existingArticle
});
existingArticle.ArticleAuthors = manyToManyBullshit;
db.Articles.Update(existingArticle);
db.SaveChanges();
}
else
{
var newArticle = new Article
{
DOI = article.DOI,
Title = article.Title,
YearOfPublication = article.YearOfPublication
};
var aa = new ArticleAuthors
{
Article = newArticle,
User = user
};
newArticle.ArticleAuthors = new List <ArticleAuthors> {
aa
};
db.Articles.Add(newArticle);
db.SaveChanges();
}
}
}
return(RedirectToAction("MyOverview", "Profile"));
}
public async Task <IActionResult> CollaboratorActivity(CollaboratorActivityViewModel collaboratorActivityViewModel)
{
if (collaboratorActivityViewModel.searchString == null)
{
collaboratorActivityViewModel.searchString = "";
}
collaboratorActivityViewModel.CurrentFilter = collaboratorActivityViewModel.searchString;
List <int> collaboratorsIds = GetCollaboratorsIds();
if (collaboratorsIds != null && collaboratorsIds.Count > 0)
{
using (var _context = new CrossRefContext())
{
List <User> users = GetUsers();
List <int> searchedUsersIds = users
.Where(x => collaboratorActivityViewModel.searchString == null ||
(x.FirstName + " " + x.LastName).ToUpper().Contains(collaboratorActivityViewModel.searchString.ToUpper()))
.Select(x => x.Id)
.ToList();
List <Article> publications = await _context.Articles.Include(x => x.ArticleAuthors).ThenInclude(x => x.User)
.Where(x => x.ArticleAuthors.Select(y => y.UserId).Intersect(collaboratorsIds).Any() &&
x.ArticleAuthors.Select(y => y.UserId).Intersect(searchedUsersIds).Any())
.OrderByDescending(x => x.Published)
.Skip((collaboratorActivityViewModel.CurrentPage - 1) * collaboratorActivityViewModel.PageSize)
.Take(collaboratorActivityViewModel.PageSize)
.ToListAsync();
List <CollaboratorsPublicationViewModel> collaboratorsPublications = new List <CollaboratorsPublicationViewModel>();
foreach (Article publication in publications)
{
string authorsNames = "";
var authors = publication?.ArticleAuthors?.Select(x => x.User.FirstName + " " + x.User.LastName + " ");
if (authors != null)
{
authorsNames = String.Join(String.Empty, authors);
}
var author = users
.FirstOrDefault(x => publication.ArticleAuthors.Select(y => y.UserId).Contains(x.Id) &&
(x.FirstName + " " + x.LastName).ToUpper().Contains(collaboratorActivityViewModel.searchString.ToUpper()));
string authorName = author?.FirstName + " " + author.LastName;
CollaboratorsPublicationViewModel pub = new CollaboratorsPublicationViewModel()
{
Title = publication.Title,
Published = publication.Published,
AuthorName = authorName,
AuthorsNames = authorsNames,
Url = publication.Url,
Type = publication.Type,
Year = publication.YearOfPublication
};
collaboratorsPublications.Add(pub);
}
CollaboratorActivityViewModel collaboratorViewModel = new CollaboratorActivityViewModel()
{
Publications = collaboratorsPublications,
Count = collaboratorsPublications.Count()
};
return(View(collaboratorViewModel));
}
}
else
{
CollaboratorActivityViewModel collaboratorViewModel = new CollaboratorActivityViewModel()
{
Publications = new List <CollaboratorsPublicationViewModel>(),
Count = 0
};
return(View(collaboratorViewModel));
}
}
