public void ConditionalFieldChangeTestForGroup()
{
var mock = new MockedProject();
var claim = mock.CreateClaim(mock.Group, mock.Player);
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.ConditionalField.ProjectFieldId, "test" }
});
Assert.AreEqual($"{{\"{mock.ConditionalField.ProjectFieldId}\":\"test\"}}", claim.JsonData);
Assert.AreEqual(_original.Character.JsonData, mock.Character.JsonData,
"Adding claim should not modify any character fields");
}
public void TryToChangeAnotherUserCharacter()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
Should.Throw <NoAccessToProjectException>(() =>
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
mock.Character,
new Dictionary <int, string>()
{
{ mock.CharacterField.ProjectFieldId, "test" },
},
_generator));
}
public void TryToChangeMasterOnlyFieldOnAdd()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
_ = Should.Throw <NoAccessToProjectException>(() =>
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
mock.CreateClaim(mock.Character, mock.Player),
new Dictionary <int, string?>()
{
{ mock.MasterOnlyField.ProjectFieldId, "test" },
},
_generator));
}
public void HiddenFieldChangeFailedTest()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
var claim = mock.CreateClaim(mock.Group, mock.Player);
Should.Throw <NoAccessToProjectException>(() =>
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.HideForUnApprovedClaim.ProjectFieldId, "test" },
},
_generator));
}
public void ApprovedClaimChangeTest()
{
var mock = new MockedProject();
var claim = mock.CreateClaim(mock.Character, mock.Player);
claim.ClaimStatus = Claim.Status.Approved;
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.CharacterField.ProjectFieldId, "test" }
});
Assert.AreEqual(
$"{{\"{mock.CharacterField.ProjectFieldId}\":\"test\",\"{mock.PublicField.ProjectFieldId}\":\"Public\"}}",
mock.Character.JsonData);
Assert.AreEqual("{}", claim.JsonData);
}
public void ApprovedClaimHiddenChangeTest()
{
var mock = new MockedProject();
var claim = mock.CreateApprovedClaim(mock.Character, mock.Player);
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.HideForUnApprovedClaim.ProjectFieldId, "test" },
{ mock.CharacterField.ProjectFieldId, null }
},
generator);
Assert.AreEqual(
$"{{\"{mock.HideForUnApprovedClaim.ProjectFieldId}\":\"test\",\"{mock.PublicField.ProjectFieldId}\":\"Public\"}}",
mock.Character.JsonData);
Assert.AreEqual("{}", claim.JsonData);
}
public void DisableUnapprovedClaimToChangeCharacterTest()
{
var mock = new MockedProject();
var claim = mock.CreateClaim(mock.Character, mock.Player);
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.CharacterField.ProjectFieldId, "test" }
});
Assert.AreEqual(_original.Character.JsonData, mock.Character.JsonData, "Adding claim should not modify any character fields");
CollectionAssert.AreEqual(
_original.Character.Groups.Select(g => g.CharacterGroupId).ToList(),
mock.Character.Groups.Select(g => g.CharacterGroupId).ToList(),
"Adding claim should not modify any character groups");
Assert.AreEqual($"{{\"{mock.CharacterField.ProjectFieldId}\":\"test\"}}", claim.JsonData);
}
public void ApprovedClaimChangeTest()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
var claim = mock.CreateApprovedClaim(mock.Character, mock.Player);
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.CharacterField.ProjectFieldId, "test" },
},
_generator);
mock.Character.FieldValuesShouldBe(new FieldWithValue(mock.CharacterField, "test"));
ShouldBeTestExtensions.ShouldBe(claim.JsonData, "{}");
}
public void MasterHiddenChangeTest()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
var publicField = new FieldWithValue(mock.PublicField, "Public");
MockedProject.AssignFieldValues(mock.Character, publicField);
FieldSaveHelper.SaveCharacterFields(
mock.Master.UserId,
mock.Character,
new Dictionary <int, string>()
{
{ mock.HideForUnApprovedClaim.ProjectFieldId, "test" },
{ mock.CharacterField.ProjectFieldId, null },
},
_generator);
mock.Character.FieldValuesShouldBe(new FieldWithValue(mock.HideForUnApprovedClaim, "test"), publicField);
}
public async Task SaveFieldsFromClaim(int projectId,
int characterId,
IReadOnlyDictionary<int, string?> newFieldValue)
{
//TODO: Prevent lazy load here - use repository
var claim = await LoadProjectSubEntityAsync<Claim>(projectId, characterId);
var updatedFields = FieldSaveHelper.SaveCharacterFields(CurrentUserId, claim, newFieldValue,
FieldDefaultValueGenerator);
if (updatedFields.Any(f => f.Field.FieldBoundTo == FieldBoundTo.Character) && claim.Character != null)
{
MarkChanged(claim.Character);
}
var user = await GetCurrentUser();
var email = EmailHelpers.CreateFieldsEmail(claim, s => s.FieldChange, user, updatedFields);
await UnitOfWork.SaveChangesAsync();
await EmailService.Email(email);
}
public void SaveOnAddTest()
{
var mock = new MockedProject();
var claim = mock.CreateClaim(mock.Character, mock.Player);
// ReSharper disable once MustUseReturnValue
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.CharacterField.ProjectFieldId, "test" }
},
generator);
Assert.AreEqual(_original.Character.JsonData, mock.Character.JsonData, "Adding claim should not modify any character fields");
CollectionAssert.AreEqual(
_original.Character.Groups.Select(g => g.CharacterGroupId).ToList(),
mock.Character.Groups.Select(g => g.CharacterGroupId).ToList(),
"Adding claim should not modify any character groups");
Assert.AreEqual($"{{\"{mock.CharacterField.ProjectFieldId}\":\"test\"}}", claim.JsonData);
}
public void ConditionalFieldChangeTestForGroup()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
var claim = mock.CreateClaim(mock.Group, mock.Player);
var conditionalField = mock.CreateConditionalField();
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ conditionalField.ProjectFieldId, "test" },
},
_generator);
ShouldBeTestExtensions.ShouldBe(claim.JsonData,
$"{{\"{conditionalField.ProjectFieldId}\":\"test\"}}");
ShouldBeTestExtensions.ShouldBe(mock.Character.JsonData,
_original.Character.JsonData,
"Adding claim should not modify any character fields");
}
public void SkipOptionalField()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
mock.CharacterField.MandatoryStatus = MandatoryStatus.Optional;
var claim = mock.CreateApprovedClaim(mock.Character, mock.Player);
var exception = Should.NotThrow(() =>
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.CharacterField.ProjectFieldId, "" },
},
_generator));
mock.Character.JsonData.ShouldBe("{}");
}
public void TryToSkipMandatoryField()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
mock.CharacterField.MandatoryStatus = MandatoryStatus.Required;
var claim = mock.CreateApprovedClaim(mock.Character, mock.Player);
var exception = Should.Throw <FieldRequiredException>(() =>
FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string>()
{
{ mock.CharacterField.ProjectFieldId, "" },
},
_generator));
exception.FieldName.ShouldBe(mock.CharacterField.FieldName);
}
public async Task AddCharacter(AddCharacterRequest addCharacterRequest)
{
var project = await ProjectRepository.GetProjectAsync(addCharacterRequest.ProjectId);
_ = project.RequestMasterAccess(CurrentUserId, acl => acl.CanEditRoles);
_ = project.EnsureProjectActive();
var character = new Character
{
ParentCharacterGroupIds =
await ValidateCharacterGroupList(addCharacterRequest.ProjectId, Required(addCharacterRequest.ParentCharacterGroupIds)),
ProjectId = addCharacterRequest.ProjectId,
IsPublic = addCharacterRequest.IsPublic,
IsActive = true,
IsAcceptingClaims = addCharacterRequest.IsAcceptingClaims,
HidePlayerForCharacter = addCharacterRequest.HidePlayerForCharacter,
IsHot = addCharacterRequest.IsHot,
};
Create(character);
MarkTreeModified(project);
if (project.Details.CharacterNameLegacyMode)
{
character.CharacterName = Required(addCharacterRequest.Name);
// If not legacy mode, character name will be updated inside SaveCharacterFields(..)
}
// ReSharper disable once MustUseReturnValue
//TODO we do not send message for creating character
_ = FieldSaveHelper.SaveCharacterFields(CurrentUserId,
character,
addCharacterRequest.FieldValues,
FieldDefaultValueGenerator);
await UnitOfWork.SaveChangesAsync();
}
public void ApprovedClaimHiddenChangeTest()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
var claim = mock.CreateApprovedClaim(mock.Character, mock.Player);
var publicField = new FieldWithValue(mock.PublicField, "Public");
MockedProject.AssignFieldValues(claim, publicField);
_ = FieldSaveHelper.SaveCharacterFields(
mock.Player.UserId,
claim,
new Dictionary <int, string?>()
{
{ mock.HideForUnApprovedClaim.ProjectFieldId, "test" },
{ mock.CharacterField.ProjectFieldId, null },
},
_generator);
mock.Character.FieldValuesShouldBe(new FieldWithValue(mock.HideForUnApprovedClaim, "test"), publicField);
ShouldBeTestExtensions.ShouldBe(claim.JsonData, "{}");
}
public async Task EditCharacter(int currentUserId,
int characterId,
int projectId,
string name,
bool isPublic,
IReadOnlyCollection <int> parentCharacterGroupIds,
bool isAcceptingClaims,
bool hidePlayerForCharacter,
IReadOnlyDictionary <int, string?> characterFields,
bool isHot)
{
var character = await LoadProjectSubEntityAsync <Character>(projectId, characterId);
_ = character.RequestMasterAccess(currentUserId, acl => acl.CanEditRoles);
_ = character.EnsureProjectActive();
var changedAttributes = new Dictionary <string, PreviousAndNewValue>();
if (character.Project.Details.CharacterNameLegacyMode)
{
changedAttributes.Add("Имя персонажа",
new PreviousAndNewValue(name, character.CharacterName.Trim()));
character.CharacterName = name.Trim();
// If not legacy mode, character name will be updated inside SaveCharacterFields(..)
}
character.IsAcceptingClaims = isAcceptingClaims;
character.IsPublic = isPublic;
character.HidePlayerForCharacter = hidePlayerForCharacter;
character.IsHot = isHot;
character.IsActive = true;
character.ParentCharacterGroupIds = await ValidateCharacterGroupList(projectId,
Required(parentCharacterGroupIds),
ensureNotSpecial : true);
var changedFields = FieldSaveHelper.SaveCharacterFields(currentUserId,
character,
characterFields,
FieldDefaultValueGenerator);
MarkChanged(character);
MarkTreeModified(character.Project); //TODO: Can be smarter
FieldsChangedEmail?email = null;
changedAttributes = changedAttributes
.Where(attr => attr.Value.DisplayString != attr.Value.PreviousDisplayString)
.ToDictionary(x => x.Key, x => x.Value);
if (changedFields.Any() || changedAttributes.Any())
{
var user = await UserRepository.GetById(currentUserId);
email = EmailHelpers.CreateFieldsEmail(
character,
s => s.FieldChange,
user,
changedFields,
changedAttributes);
}
await UnitOfWork.SaveChangesAsync();
if (email != null)
{
await EmailService.Email(email);
}
}
public async Task AddClaimFromUser(int projectId,
int?characterGroupId,
int?characterId,
string claimText,
IReadOnlyDictionary <int, string> fields)
{
var source = await ProjectRepository.GetClaimSource(projectId, characterGroupId, characterId);
source.EnsureCanAddClaim(CurrentUserId);
var responsibleMaster = source.GetResponsibleMasters().FirstOrDefault();
var claim = new Claim()
{
CharacterGroupId = characterGroupId,
CharacterId = characterId,
ProjectId = projectId,
PlayerUserId = CurrentUserId,
PlayerAcceptedDate = Now,
CreateDate = Now,
ClaimStatus = Claim.Status.AddedByUser,
ResponsibleMasterUserId = responsibleMaster?.UserId,
ResponsibleMasterUser = responsibleMaster,
LastUpdateDateTime = Now,
CommentDiscussion = new CommentDiscussion()
{
CommentDiscussionId = -1, ProjectId = projectId
},
};
if (!string.IsNullOrWhiteSpace(claimText))
{
claim.CommentDiscussion.Comments.Add(new Comment
{
CommentDiscussionId = -1,
AuthorUserId = CurrentUserId,
CommentText = new CommentText {
Text = new MarkdownString(claimText)
},
CreatedAt = Now,
IsCommentByPlayer = true,
IsVisibleToPlayer = true,
ProjectId = projectId,
LastEditTime = Now,
ExtraAction = CommentExtraAction.NewClaim,
});
}
UnitOfWork.GetDbSet <Claim>().Add(claim);
var updatedFields = FieldSaveHelper.SaveCharacterFields(CurrentUserId, claim, fields, FieldDefaultValueGenerator);
var claimEmail = await CreateClaimEmail <NewClaimEmail>(claim, claimText ?? "", s => s.ClaimStatusChange,
CommentExtraAction.NewClaim);
claimEmail.UpdatedFields = updatedFields;
await UnitOfWork.SaveChangesAsync();
await EmailService.Email(claimEmail);
if (claim.Project.Details.AutoAcceptClaims)
{
var userId = claim.ResponsibleMasterUserId ?? claim.Project.ProjectAcls.First().UserId;
StartImpersonate(userId);
//TODO[Localize]
await ApproveByMaster(projectId,
claim.ClaimId,
"Ваша заявка была принята автоматически");
ResetImpersonation();
}
}
public async Task <int> MoveToSecondRole(int projectId, int claimId, int characterId)
{
var oldClaim = (await ClaimsRepository.GetClaim(projectId, claimId)).RequestAccess(CurrentUserId); //TODO Specific right
oldClaim.EnsureStatus(Claim.Status.CheckedIn);
Debug.Assert(oldClaim.Character != null, "oldClaim.Character != null");
oldClaim.Character.InGame = false;
MarkChanged(oldClaim.Character);
var source = await CharactersRepository.GetCharacterAsync(projectId, characterId);
MarkChanged(source);
// TODO improve valitdation here
//source.EnsureCanMoveClaim(oldClaim);
var responsibleMaster = source.GetResponsibleMasters().FirstOrDefault();
var claim = new Claim()
{
CharacterGroupId = null,
CharacterId = characterId,
ProjectId = projectId,
PlayerUserId = oldClaim.PlayerUserId,
PlayerAcceptedDate = Now,
CreateDate = Now,
ClaimStatus = Claim.Status.Approved,
CurrentFee = 0,
ResponsibleMasterUserId = responsibleMaster?.UserId,
ResponsibleMasterUser = responsibleMaster,
LastUpdateDateTime = Now,
MasterAcceptedDate = Now,
CommentDiscussion =
new CommentDiscussion()
{
CommentDiscussionId = -1, ProjectId = projectId
},
};
claim.CommentDiscussion.Comments.Add(new Comment
{
CommentDiscussionId = -1,
AuthorUserId = CurrentUserId,
CommentText = new CommentText {
Text = new MarkdownString(".")
},
CreatedAt = Now,
IsCommentByPlayer = false,
IsVisibleToPlayer = true,
ProjectId = projectId,
LastEditTime = Now,
ExtraAction = CommentExtraAction.SecondRole,
});
oldClaim.ClaimStatus = Claim.Status.Approved;
source.ApprovedClaim = claim;
AddCommentImpl(oldClaim, null, ".", true, CommentExtraAction.OutOfGame);
UnitOfWork.GetDbSet <Claim>().Add(claim);
// ReSharper disable once UnusedVariable TODO decide if we should send email if FieldDefaultValueGenerator changes something
var updatedFields =
FieldSaveHelper.SaveCharacterFields(CurrentUserId, claim, new Dictionary <int, string>(),
FieldDefaultValueGenerator);
await UnitOfWork.SaveChangesAsync();
var claimEmail = await CreateClaimEmail <SecondRoleEmail>(claim, "",
s => s.ClaimStatusChange,
CommentExtraAction.NewClaim);
await EmailService.Email(claimEmail);
return(claim.ClaimId);
}
