public async Task <int?> RateIssue(string userId, RateApiRequestModel model)
{
var issue = this.dbContext.Issues.Find(model.Id);
if (issue != null)
{
var userIssue = issue.UsersIssues.FirstOrDefault(ui => ui.UserId == userId);
if (userIssue == null)
{
userIssue = new UserIssue
{
UserId = userId,
IssueId = model.Id,
Score = model.Score,
};
issue.UsersIssues.Add(userIssue);
this.dbContext.Update(issue);
await this.dbContext.SaveChangesAsync();
}
else
{
userIssue.Score = model.Score;
this.dbContext.Update(issue);
await this.dbContext.SaveChangesAsync();
}
return(model.Score);
}
return(null);
}
public async Task RemoveIssueFromList(string userId, int id)
{
var issue = this.dbContext.Issues.Find(id);
if (issue == null)
{
throw new KeyNotFoundException("Issue with given id does not exist.");
}
var user = this.dbContext.Users
.Include(u => u.UsersIssues)
.FirstOrDefault(u => u.Id == userId);
if (!user.UsersIssues.Any(uv => uv.Issue == issue))
{
throw new InvalidOperationException("User does not have given issue in their list.");
}
var userIssue = new UserIssue {
User = user, Issue = issue
};
user.UsersIssues.Remove(userIssue);
await this.dbContext.SaveChangesAsync();
}
public void Add(UserIssue issue)
{
using (var db = new UserIssueContext())
{
db.CreateIssue(issue);
}
}
public async Task <Issue> InsertIssueAsync(string userId, Issue data)
{
Issue issue = null;
using (var transaction = await this._db.Database.BeginTransactionAsync())
{
try
{
this._db.Add(data);
var issueId = this._db.SaveChanges();
var userIssue = new UserIssue
{
IssueId = issueId,
UserId = userId
};
this._db.Add(userIssue);
this._db.SaveChanges();
await transaction.CommitAsync();
issue = await this._db.FindAsync <Issue>(issueId);
}
catch (Exception ex)
{
this._logger?.LogError(ex, ex.Message);
}
}
return(issue);
}
public void Modify(UserIssue issue, Action <UserIssue> changes)
{
changes.Invoke(issue);
using (var db = new UserIssueContext())
{
db.UpdateIssue(issue);
}
}
public void CreateAlreadyExistingIssueThrowsTest()
{
var issue = new UserIssue
{
Id = TestConstants.TestUserIssueMessageId,
UserId = 111,
Contents = "Contents..."
};
Assert.Throws <ArgumentException>(() => userIssueRepository.Add(issue));
}
public void CreateNewIssueTest()
{
var issue = new UserIssue
{
Id = 500,
UserId = 1,
Contents = "Hello, World!"
};
userIssuesService.NewIssue(issue);
}
internal void CreateIssue(UserIssue issue)
{
try
{
Add(issue);
SaveChanges();
}
catch (DbUpdateException)
{
throw new ArgumentException("User Issue already exists.");
}
}
private void AssertIssueExists(UserIssue issue)
{
var storedIssueByUser = userIssueRepository.GetByUserId(issue.UserId);
var storedIssueByMessage = userIssueRepository.GetByMessageId(issue.Id);
Assert.NotNull(storedIssueByUser);
Assert.NotNull(storedIssueByMessage);
Assert.AreSame(storedIssueByMessage, storedIssueByMessage);
Assert.AreEqual(issue.Contents, storedIssueByUser.Contents);
Assert.AreEqual(issue.Contents, storedIssueByMessage.Contents);
}
internal void UpdateIssue(UserIssue issue)
{
try
{
Update(issue);
SaveChanges();
}
catch (DbUpdateException)
{
throw new ArgumentException("User Issue doesn't exist.");
}
}
public void ModifyNonExistentThrowsTest()
{
var issue = new UserIssue
{
Id = TestConstants.NonExistentId,
UserId = 115,
Contents = "NON-EXISTENT"
};
Assert.Throws <ArgumentException>(
() => userIssueRepository.Modify(issue, i => i.Contents = "ABC")
);
}
public void CreateNewIssueTest()
{
var issue = new UserIssue
{
Id = 10,
UserId = 123,
Contents = "Hello, World!"
};
userIssueRepository.Add(issue);
AssertIssueExists(issue);
}
public IActionResult AddForUser(AddForUserViewModel model)
{
if (ModelState.IsValid)
{
foreach (var issueId in model.IssuesId)
{
UserIssue userIssue = new UserIssue();
userIssue.UserId = model.UserId;
userIssue.IssueId = issueId;
_db.UserIssues.Add(userIssue);
_db.SaveChanges();
}
}
return(RedirectToAction("ListUsers", "UsersManage"));
}
public IActionResult DeleteIssueUser(int issueId, string userId)
{
if (issueId != 0 && userId != null)
{
UserIssue model = _db.UserIssues.Where(i => i.IssueId == issueId)
.FirstOrDefault(i => i.UserId == userId);
if (model != null)
{
_db.UserIssues.Remove(model);
_db.SaveChanges();
return(Json("true"));
}
}
return(Json("false"));
}
public void ModifyNewIssueTest()
{
const string expectedContents = "Different";
var issue = new UserIssue
{
Id = 112,
UserId = 113,
Contents = "Hello, World!"
};
userIssueRepository.Add(issue);
userIssueRepository.Modify(issue, u => u.Contents = expectedContents);
Assert.AreEqual(expectedContents, issue.Contents);
AssertIssueExists(issue);
}
public async Task AddIssueToList(string userId, int id)
{
var issue = this.dbContext.Issues.Find(id);
if (issue == null)
{
throw new KeyNotFoundException("Issue with given id does not exist.");
}
if (issue.UsersIssues.Any(ua => ua.UserId == userId))
{
throw new InvalidOperationException("User has already added given issue to their list.");
}
var userIssue = new UserIssue {
UserId = userId, Issue = issue
};
issue.UsersIssues.Add(userIssue);
await this.dbContext.SaveChangesAsync();
}
public void NewIssue(UserIssue issue)
{
userIssueRepository.Add(issue);
}
private static void AssertIsTestDbTestEntry(UserIssue issue)
{
Assert.NotNull(issue);
Assert.AreEqual(TestConstants.TestUserIssueMessageId, issue.Id);
Assert.AreEqual(TestConstants.TestUserIssueContents, issue.Contents);
}
