public async Task HandleAsync(CreateSavingTypeCommand message, CancellationToken token = default(CancellationToken))
{
var type = SavingType.Create(Guid.NewGuid(), message.UserId, message.Name, message.Symbol);
_types.Add(type);
await _types.SaveChangesAsync(token);
}
public void ShouldHaveModifiedEvent()
{
// Arrange
Guid expectedId = Guid.NewGuid();
string expectedName = "ModifiedName";
string expectedSymbol = "ModifiedSymbol";
// Act
SavingType actual = SavingType.Create(expectedId, Guid.NewGuid(), "Name",
"Symbol");
actual.FlushUncommitedEvents();
actual.Modify(expectedName, expectedSymbol, 1);
// Assert
Assert.IsTrue(actual.Events != null);
Assert.IsTrue(actual.Events.Count == 1);
var events = actual.FlushUncommitedEvents();
Assert.IsTrue(events != null);
Assert.IsTrue(events.Length == 1);
Assert.IsTrue(events[0] is SavingTypeModifiedEvent);
SavingTypeModifiedEvent @event = events[0] as SavingTypeModifiedEvent;
Assert.IsTrue(@event.EntityId == expectedId);
Assert.IsTrue(@event.Name == expectedName);
Assert.IsTrue(@event.Symbol == expectedSymbol);
}
public async Task <IActionResult> Edit(int id, [Bind("SavingTypeId,Name,MonthTerm,Interest")] SavingType savingType)
{
if (id != savingType.SavingTypeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(savingType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SavingTypeExists(savingType.SavingTypeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(savingType));
}
public async Task <IActionResult> Create([Bind("SavingTypeId,Name,MonthTerm,Interest")] SavingType savingType)
{
if (ModelState.IsValid)
{
_context.Add(savingType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(savingType));
}
public static void SaveAchievements(SavingType savingType)
{
Debug.Log(Application.persistentDataPath);
string savingDirectory = Path.Combine(Application.persistentDataPath, ACHIEVEMENTS_SAVE_FOLDER);
savingDirectory = savingDirectory.Replace(@"\", @"/");
switch (savingType)
{
case SavingType.PlayerSave:
Path.Combine(savingDirectory, "Achievement_Save");
break;
case SavingType.DefaultSave:
Path.Combine(savingDirectory, "Default_Achievement_Save");
break;
default:
break;
}
Achievement[] achievementArray = AchievementManager.achivementDictionary.Values.ToArray();
_Achievement[] achievementWrapper = new _Achievement[achievementArray.Length];
for (int i = 0; i < achievementArray.Length; i++)
{
achievementWrapper[i].name = achievementArray[i].name;
achievementWrapper[i].description = achievementArray[i].description;
achievementWrapper[i].achievementImageName = achievementArray[i].achievementImage.name;
achievementWrapper[i].progress = achievementArray[i].progress;
achievementWrapper[i].progressGoal = achievementArray[i].progressGoal;
achievementWrapper[i].isCompleted = achievementArray[i].isCompleted;
}
string outputString = JsonUtility.ToJson(new AchievementWrapper()
{
achievements = achievementWrapper
});
byte[] encryptedString = RijndaelEncryption.Encrypt(outputString, ENCRYPTION_KEY);
File.WriteAllBytes(savingDirectory, encryptedString);
}
public void ShouldCreateNewModel()
{
// Arrange
Guid expectedId = Guid.NewGuid();
Guid expectedUserId = Guid.NewGuid();
string expectedName = "Name";
string expectedSymbol = "Symbol";
// Act
SavingType actual = SavingType.Create(expectedId, expectedUserId, expectedName,
expectedSymbol);
// Assert
Assert.IsTrue(actual != null);
Assert.IsTrue(actual.Id == expectedId);
Assert.IsTrue(actual.Name == expectedName);
Assert.IsTrue(actual.Symbol == expectedSymbol);
Assert.IsTrue(!string.IsNullOrEmpty(actual.SearchValue));
}
public static void LoadAchievements(SavingType savingType)
{
string loadingDirectory = Path.Combine(Application.persistentDataPath, ACHIEVEMENTS_SAVE_FOLDER);
byte[] encryptedJson;
string decryptedJson = string.Empty;
switch (savingType)
{
case SavingType.PlayerSave:
Path.Combine(loadingDirectory, "Achievement_Save");
break;
case SavingType.DefaultSave:
Path.Combine(loadingDirectory, "Default_Achievement_Save");
break;
default:
break;
}
loadingDirectory = loadingDirectory.Replace(@"\", @"/");
encryptedJson = File.ReadAllBytes(loadingDirectory);
decryptedJson = RijndaelEncryption.Decrypt(encryptedJson, ENCRYPTION_KEY);
AchievementManager.achivementDictionary.Clear();
foreach (_Achievement achievement in JsonUtility.FromJson <AchievementWrapper>(decryptedJson).achievements)
{
Achievement dictAchievement = new Achievement();
dictAchievement.name = achievement.name;
dictAchievement.description = achievement.description;
dictAchievement.achievementImage = Resources.Load <Sprite>(ACHIEVEMENT_ICON_PATH + '/' + achievement.achievementImageName);
dictAchievement.progress = achievement.progress;
dictAchievement.progressGoal = achievement.progressGoal;
dictAchievement.isCompleted = achievement.isCompleted;
AchievementManager.achivementDictionary.Add(achievement.name, dictAchievement);
}
}
public async Task ShouldDeleteExisting()
{
// Arrange
SavingType entity = SavingType.Create(Guid.NewGuid(), Guid.NewGuid(), "Name", "Symbol");
var repository = new Mock <ISavingTypeRepository>();
repository.Setup(e =>
e.GetByIdAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(entity);
DeleteSavingTypeCommand cmd = new DeleteSavingTypeCommand(entity.Id);
SavingTypeCommandHandler actual = new SavingTypeCommandHandler(repository.Object);
// Act
await actual.HandleAsync(cmd);
// Assert
repository.Verify(e =>
e.Delete(It.Is <SavingType>(a => a.Equals(entity))),
Times.Once
);
}
public async Task ShouldModifyExisting()
{
// Arrange
Guid expectedId = Guid.NewGuid();
string expectedName = "Modified Name";
SavingType entity = SavingType.Create(expectedId, Guid.NewGuid(), "Name", "Symbol");
var repository = new Mock <ISavingTypeRepository>();
repository.Setup(e =>
e.GetByIdAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(entity);
ModifySavingTypeCommand cmd =
new ModifySavingTypeCommand(expectedId, expectedName, "Symbol", 1);
SavingTypeCommandHandler actual = new SavingTypeCommandHandler(repository.Object);
// Act
await actual.HandleAsync(cmd);
// Assert
Assert.IsTrue(entity.Id == expectedId);
Assert.IsTrue(entity.Name == expectedName);
}
public void ShouldHaveDeletedEvent()
{
// Arrange
Guid expectedId = Guid.NewGuid();
// Act
SavingType actual = SavingType.Create(expectedId, Guid.NewGuid(), "Name",
"Symbol");
actual.FlushUncommitedEvents();
actual.Delete();
// Assert
Assert.IsTrue(actual.Events != null);
Assert.IsTrue(actual.Events.Count == 1);
var events = actual.FlushUncommitedEvents();
Assert.IsTrue(events != null);
Assert.IsTrue(events.Length == 1);
Assert.IsTrue(events[0] is SavingTypeDeletedEvent);
SavingTypeDeletedEvent @event = events[0] as SavingTypeDeletedEvent;
Assert.IsTrue(@event.EntityId == expectedId);
}
