private void UpdateNextRepeat(Domain.Card card, QuestionSideEnum questionSide)
{
var nextRepeat = nextRepeatCalculator.Calculate(card, questionSide);
var side = questionSide == QuestionSideEnum.Heads ? card.Heads : card.Tails;
side.State.NextRepeat = nextRepeat;
}
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken)
{
var user = await _context.Users.FindAsync(request.UserId);
if (user == null)
{
throw new RestException(HttpStatusCode.NotFound, new { user = "******" });
}
var card = new Domain.Card
{
AppUser = user,
CardNumber = request.CardNumber,
Created = DateTime.Now
};
_context.Cards.Add(card);
var success = await _context.SaveChangesAsync() > 0;
if (success)
{
return(Unit.Value);
}
throw new Exception("Problem saving changes");
}
public async Task <long> Handle(AddCardCommand request, CancellationToken cancellationToken)
{
var group = await dbContext.Groups.SingleOrDefaultAsync(g => g.Id == request.GroupId);
if (group == null)
{
throw new Exception();
}
var heads = Domain.Side.New(request.Front.Value, request.Front.Example);
var tails = Domain.Side.New(request.Back.Value, request.Back.Example);
var newCard = new Domain.Card
{
Group = group,
Heads = heads,
Tails = tails,
IsVisible = request.IsVisible,
WordCreationDate = dateTimeProvider.GetDate(),
};
await dbContext.Words.AddAsync(newCard);
await dbContext.SaveChangesAsync();
return(newCard.Id);
}
public Card(Domain.Card obj)
{
CardholderName = obj.CardholderName?.EncryptedString;
Brand = obj.Brand?.EncryptedString;
Number = obj.Number?.EncryptedString;
ExpMonth = obj.ExpMonth?.EncryptedString;
ExpYear = obj.ExpYear?.EncryptedString;
Code = obj.Code?.EncryptedString;
}
private void AddRepeat(Domain.Card card, QuestionSideEnum questionSide, RepeatResultEnum repeatReuslt, Domain.Lesson lesson)
{
var newResult = new Repeat
{
DateTime = timeProvider.GetTime(),
Lesson = lesson,
QuestionSide = questionSide,
Result = (int)repeatReuslt,
Word = card
};
dbContext.Repeats.Add(newResult);
}
private Domain.Card GetNextRepeat(Domain.Card minHeads, Domain.Card minTails)
{
if (minHeads == null && minTails == null)
{
return(null);
}
if (minHeads == null)
{
return(minTails);
}
if (minTails == null)
{
return(minHeads);
}
return(minHeads.Heads.State.NextRepeat < minTails.Tails.State.NextRepeat ? minHeads : minTails);
}
public async Task Handle_WhenSameCardDifferentUser_ExpectedFailureAsync()
{
_mocker.GetMock <IMediator>()
.Setup(x => x.Send(It.IsAny <GetBankPaymentVerification>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var cardResponseMock = new Domain.Card(Guid.NewGuid(), "1234567891234567", 541, new Domain.ExpirationDate(2025, 1));
_mocker.GetMock <IMediator>()
.Setup(x => x.Send(It.IsAny <GetCardByNumber>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Option <Domain.Card> .Some(cardResponseMock));
var paymentTimeStampMock = DateTime.UtcNow;
var userIdMock = Guid.NewGuid();
var paymentListMock = new List <Payment>()
{
new Payment(Guid.NewGuid(), new Domain.Card(userIdMock, "1234567891234567", 541, new Domain.ExpirationDate(2025, 1)), new Domain.Money(30, "EUR"), DateTime.UtcNow.AddSeconds(-10))
};
_mocker.GetMock <IPaymentRepository>()
.Setup(x => x.GetPaymentsByUserIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(paymentListMock);
_mocker.GetMock <ICardRepository>()
.Setup(x => x.GetCardByNumberAsync(It.IsAny <string>()))
.ReturnsAsync(cardResponseMock);
var requestMock = new CreatePayment
(
userIdMock,
paymentTimeStampMock,
new Common.Money(25, "EUR"),
new Common.Card("1234567891234567", 541, new Common.ExpirationDate(2025, 1))
);
var result = await _classUnderTest.Handle(requestMock, It.IsAny <CancellationToken>());
result.ShouldBeLeft(fail =>
{
fail.Should().NotBeNull();
});
_mocker.GetMock <IPaymentRepository>().Verify(x => x.SavePaymentAsync(It.IsAny <Payment>()), Times.Never);
_mocker.GetMock <IMediator>().Verify(x => x.Send(It.IsAny <GetBankPaymentVerification>(), It.IsAny <CancellationToken>()), Times.Never);
}
public static CardRepeatDto ConvertIntoRepeatDto(Domain.Card card, bool revert = false)
=> revert
? new CardRepeatDto
{
Id = card.Id,
Answer = new SideRepeatDto
{
Value = card.Heads.Value,
Example = card.Heads.Example,
Drawer = card.Heads.State.Drawer.Value,
Language = card.Group.GroupLanguage1
},
Question = new SideRepeatDto
{
Value = card.Tails.Value,
Example = card.Tails.Example,
Drawer = card.Tails.State.Drawer.Value,
Language = card.Group.GroupLanguage2
}
}
: new CardRepeatDto
{
Id = card.Id,
Question = new SideRepeatDto
{
Value = card.Heads.Value,
Example = card.Heads.Example,
Drawer = card.Heads.State.Drawer.Value,
Language = card.Group.GroupLanguage1
},
Answer = new SideRepeatDto
{
Value = card.Tails.Value,
Example = card.Tails.Example,
Drawer = card.Tails.State.Drawer.Value,
Language = card.Group.GroupLanguage2
}
};
public async Task <CardEnvelope> Handle(Command request, CancellationToken cancellationToken)
{
if (await _context.Cards.Where(x => x.CardNumber == request.CardNumber).AnyAsync(cancellationToken))
{
throw new RestException(HttpStatusCode.BadRequest, new { Card = Constants.ALREADY_EXIST });
}
var auditId = _currentUserAccessor.GetAuditId();
var cardData = new Domain.Card
{
CardNumber = request.CardNumber,
IsActive = true,
CreatedDate = DateTime.Now,
AuditId = auditId
};
await _context.Cards.AddAsync(cardData, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
var card = _mapper.Map <Domain.Card, Card>(cardData);
return(new CardEnvelope(card));
}
public async Task Init()
{
logger.LogInformation("Beginnin init");
await dbContext.Database.EnsureCreatedAsync();
logger.LogInformation("finish init");
if (!options.Mocks)
{
return;
}
if (await dbContext.Users.AnyAsync(u => u.Name.Equals("testUser")))
{
return;
}
var random = new Random();
var beginningDate = timeProvider.GetTime().AddDays(-7);
Domain.User user = new Domain.User
{
Name = "testUser",
CreationDate = timeProvider.GetTime().AddDays(-7),
LastLoginDate = timeProvider.GetTime().AddDays(-1),
Password = encrypter.Md5Hash("testPassword"),
};
for (var i = 0; i < 6; i++)
{
var newLesson = new Lesson
{
StartDate = timeProvider.GetTime().AddDays(-i),
FinishDate = timeProvider.GetTime().AddDays(-i).AddMinutes(random.Next(20, 30)),
User = user
};
user.Lessons.Add(newLesson);
}
for (var i = 0; i < 7; i++)
{
var newGroup = new Domain.Group
{
GroupCreationDate = timeProvider.GetTime().AddDays(-i - 1),
GroupLanguage1 = 1,
GroupLanguage2 = 2,
Name = $"Test group {i + 1}",
User = user
};
user.Groups.Add(newGroup);
for (var j = 0; j < random.Next(15, 20); j++)
{
var newCard = new Domain.Card
{
WordCreationDate = timeProvider.GetTime().AddDays(-i - 1),
Comment = "Test comment to word",
Group = newGroup,
IsVisible = true,
Heads = new Side
{
Value = $"Word {j + 1}",
Example = $"Simple sentance where Word {j + 1} is used.",
State = new State
{
Drawer = Drawer.Create(random.Next(0, 4)),
NextRepeat = timeProvider.GetTime().AddDays(random.Next(-4, 4))
}
},
Tails = new Side
{
Value = $"Słowo {j + 1}",
Example = $"Proste zdanie gdzie słowo {j + 1} jest użyte.",
State = new State
{
Drawer = Drawer.Create(random.Next(0, 4)),
NextRepeat = timeProvider.GetTime().AddDays(random.Next(-4, 4))
}
},
};
newGroup.Words.Add(newCard);
for (var k = 0; k < random.Next(1, 7); k++)
{
var lesson = user.Lessons[random.Next(user.Lessons.Count - 1)];
var newRepeat = new Repeat
{
Lesson = lesson,
DateTime = newCard.WordCreationDate.AddDays(random.Next(-7, 0)),
Result = random.Next(-1, 1),
QuestionSide = random.Next(0, 1) > 0 ? QuestionSideEnum.Heads : QuestionSideEnum.Tails,
Word = newCard
};
lesson.Repeats.Add(newRepeat);
newCard.Repeats.Add(newRepeat);
}
}
}
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
}
public async Task <Result <Guid> > Handle(CreatePreAuthorizationForOrderCommand request, CancellationToken token)
{
var validationResult = await _orderService.ValidateConsumerOrderAsync(request.OrderId, request.RequestUser, token);
if (!validationResult.Succeeded)
{
return(Failure <Guid>(validationResult));
}
var checkResult = await _mediatr.Process(new CheckConsumerConfigurationCommand(request.RequestUser), token);
if (!checkResult.Succeeded)
{
return(Failure <Guid>(checkResult));
}
var order = await _context.Orders.SingleAsync(e => e.Id == request.OrderId, token);
using (var transaction = await _context.BeginTransactionAsync(token))
{
var card = await _context.Cards.SingleOrDefaultAsync(c => c.Identifier == request.CardIdentifier, token);
if (card == null)
{
card = new Domain.Card(Guid.NewGuid(), request.CardIdentifier,
$"Carte_{DateTime.UtcNow.ToString("YYYYMMDDTHHmmss")}", order.User);
await _context.AddAsync(card, token);
await _context.SaveChangesAsync(token);
}
var preAuthorization =
new Domain.PreAuthorization(Guid.NewGuid(), order, card, _pspOptions.PreAuthorizeUrl);
await _context.AddAsync(preAuthorization, token);
await _context.SaveChangesAsync(token);
var result = await _pspService.CreatePreAuthorizationAsync(preAuthorization, request.IpAddress, request.BrowserInfo, token);
if (!result.Succeeded)
{
return(Failure <Guid>(result));
}
preAuthorization.SetIdentifier(result.Data.Identifier);
preAuthorization.SetStatus(result.Data.Status);
preAuthorization.SetPaymentStatus(result.Data.PaymentStatus);
preAuthorization.SetExpirationDate(result.Data.ExpirationDate);
preAuthorization.SetRemaining(result.Data.Remaining);
preAuthorization.SetDebited(result.Data.Debited);
preAuthorization.SetResult(result.Data.ResultCode, result.Data.ResultMessage);
preAuthorization.SetSecureModeRedirectUrl(result.Data.SecureModeRedirectUrl);
preAuthorization.SetSecureModeNeeded(result.Data.SecureModeNeeded);
order.SetStatus(OrderStatus.Validated);
await _context.SaveChangesAsync(token);
await transaction.CommitAsync(token);
return(Success(preAuthorization.Id));
}
}
