public TestResponseModel Test(TestRequestModel model)
{
return(new TestResponseModel()
{
Ee = model.Ee + "123456"
});
}
public IHttpActionResult Post(TestRequestModel model)
{
if (model == null)
{
return this.BadRequest();
}
var db = new StudentSystemDbContext();
var testsRepo = new GenericRepository<Test>(db);
var coursesRepo = new GenericRepository<Course>(db);
List<Course> allCourses = coursesRepo.All().ToList();
var testCourse = new Course
{
Name = model.Course.Name,
Description = model.Course.Description
};
var testToAdd = new Test
{
Course = testCourse
};
testsRepo.Add(testToAdd);
testsRepo.SaveChanges();
return this.Ok();
}
public IHttpActionResult Put(int id, TestRequestModel requestTest)
{
var test = Mapper.Map <Test>(requestTest);
test = this.testsService.Upadte(id, test);
return(this.Ok(Mapper.Map <TestResponseModel>(test)));
}
public IHttpActionResult Post(TestRequestModel requestTest)
{
var test = Mapper.Map <Test>(requestTest);
test = this.testsService.Add(test);
return(this.Created("/", test));
}
public void TestMethod1()
{
TTransport transport = new TSocket("127.0.0.1", 8503);
TProtocol protocol = new TBinaryProtocol(transport);
var client = new TestService.Client(protocol);
transport.Open();
var send = new TestRequestModel()
{
Ee = "0987"
};
var result = client.Test(send);
Console.WriteLine(result);
}
public async Task <IActionResult> SubmitTest(int id, TestRequestModel testRqModel)
{
var user = await userManager.GetUser(User);
// Admin can't submit test
if (await userManager.IsInRoleAsync(user, Roles.Administrator))
{
return(Ok());
}
if (testRqModel.SucceededCardIds.Intersect(testRqModel.FailedCardIds).Count() > 0)
{
ModelState.AddModelError("", "At least a card is both succeeded and failed.");
return(BadRequest(ModelState));
}
var deck = await repository.Deck
.QueryByIdCheckingSharedDeck(user.Id, id)
.FirstOrDefaultAsync();
if (deck == null)
{
return(NotFound());
}
var newTest = new Test()
{
DateTime = testRqModel.DateTime,
Deck = deck,
Taker = user,
TestedCards = new List <TestedCard>()
};
var cards = await repository.Card
.QueryByDeckId(id)
.ToListAsync();
var succeededCards = FilterCards(cards, testRqModel.SucceededCardIds);
var failedCards = FilterCards(cards, testRqModel.FailedCardIds);
foreach (var card in succeededCards)
{
newTest.TestedCards.Add(new TestedCard()
{
Card = card,
Failed = false
});
if (deck.OwnerId == user.Id)
{
if (!card.Remembered)
{
card.FirstRememberedDate = testRqModel.DateTime;
}
card.Remembered = true;
card.LastPracticedDate = testRqModel.DateTime;
}
}
foreach (var card in failedCards)
{
newTest.TestedCards.Add(new TestedCard()
{
Card = card,
Failed = true
});
if (deck.OwnerId == user.Id)
{
card.LastPracticedDate = testRqModel.DateTime;
}
}
newTest.Score = (float)succeededCards.Count / (succeededCards.Count + failedCards.Count);
repository.Test.Create(newTest);
if (deck.OwnerId != user.Id)
{
var sharedDeck = await repository.SharedDeck
.QueryByUserIdAndDeckId(user.Id, deck.Id)
.FirstOrDefaultAsync();
if (sharedDeck == null)
{
var newSharedDeck = new SharedDeck
{
UserId = user.Id,
DeckId = deck.Id,
};
repository.SharedDeck.Create(newSharedDeck);
}
var sharedCards = await repository.SharedCard
.QueryByUserIdAndDeckId(user.Id, deck.Id)
.ToListAsync();
foreach (var cardId in testRqModel.SucceededCardIds)
{
var sharedCard = sharedCards.FirstOrDefault(s => s.CardId == cardId);
if (sharedCard != null)
{
if (!sharedCard.Remembered)
{
sharedCard.FirstRememberedDate = testRqModel.DateTime;
}
sharedCard.Remembered = true;
sharedCard.LastPracticedDate = testRqModel.DateTime;
}
else
{
var newSharedCard = new SharedCard
{
UserId = user.Id,
CardId = cardId,
Remembered = true,
FirstRememberedDate = testRqModel.DateTime,
LastPracticedDate = testRqModel.DateTime
};
repository.SharedCard.Create(newSharedCard);
}
}
foreach (var cardId in testRqModel.FailedCardIds)
{
var sharedCard = sharedCards.FirstOrDefault(s => s.CardId == cardId);
if (sharedCard != null)
{
sharedCard.LastPracticedDate = testRqModel.DateTime;
}
else
{
var newSharedCard = new SharedCard
{
UserId = user.Id,
CardId = cardId,
LastPracticedDate = testRqModel.DateTime
};
repository.SharedCard.Create(newSharedCard);
}
}
}
await repository.SaveChangesAsync();
if (deck.OwnerId == user.Id)
{
var decks = await repository.Deck
.QueryByCardIdsIncludesCardAssignmentsAndCard(testRqModel.SucceededCardIds)
.ToListAsync();
foreach (var updatedDeck in decks)
{
updatedDeck.Completed = !updatedDeck.CardAssignments.Any(ca => !ca.Card.Remembered);
}
}
else
{
var sharedDecks = await repository.SharedDeck
.QueryByUserId(user.Id)
.ToListAsync();
foreach (var sharedDeck in sharedDecks)
{
var sharedCards = await repository.SharedCard
.QueryByUserIdAndDeckId(user.Id, sharedDeck.DeckId)
.ToListAsync();
var amountCards = await repository.Card
.QueryByDeckId(sharedDeck.DeckId)
.CountAsync();
sharedDeck.Completed = sharedCards.Count == amountCards && !sharedCards.Any(s => !s.Remembered);
}
}
await repository.SaveChangesAsync();
return(Ok());
}
