/// <summary>
/// Check all member properties are equal
/// </summary>
/// <param name="memberDisplay"></param>
/// <param name="resultValue"></param>
private void AssertMemberDisplayPropertiesAreEqual(MemberDisplay memberDisplay, MemberDisplay resultValue)
{
Assert.AreNotSame(memberDisplay, resultValue);
Assert.AreEqual(memberDisplay.Id, resultValue.Id);
Assert.AreEqual(memberDisplay.Alias, resultValue.Alias);
Assert.AreEqual(memberDisplay.Username, resultValue.Username);
Assert.AreEqual(memberDisplay.Email, resultValue.Email);
Assert.AreEqual(memberDisplay.AdditionalData, resultValue.AdditionalData);
Assert.AreEqual(memberDisplay.ContentApps, resultValue.ContentApps);
Assert.AreEqual(memberDisplay.ContentType.Alias, resultValue.ContentType.Alias);
Assert.AreEqual(memberDisplay.ContentTypeAlias, resultValue.ContentTypeAlias);
Assert.AreEqual(memberDisplay.ContentTypeName, resultValue.ContentTypeName);
Assert.AreEqual(memberDisplay.ContentTypeId, resultValue.ContentTypeId);
Assert.AreEqual(memberDisplay.Icon, resultValue.Icon);
Assert.AreEqual(memberDisplay.Errors, resultValue.Errors);
Assert.AreEqual(memberDisplay.Key, resultValue.Key);
Assert.AreEqual(memberDisplay.Name, resultValue.Name);
Assert.AreEqual(memberDisplay.Path, resultValue.Path);
Assert.AreEqual(memberDisplay.SortOrder, resultValue.SortOrder);
Assert.AreEqual(memberDisplay.Trashed, resultValue.Trashed);
Assert.AreEqual(memberDisplay.TreeNodeUrl, resultValue.TreeNodeUrl);
//TODO: can we check create/update dates when saving?
//Assert.AreEqual(memberDisplay.CreateDate, resultValue.CreateDate);
//Assert.AreEqual(memberDisplay.UpdateDate, resultValue.UpdateDate);
//TODO: check all properties
Assert.AreEqual(memberDisplay.Properties.Count(), resultValue.Properties.Count());
Assert.AreNotSame(memberDisplay.Properties, resultValue.Properties);
for (var index = 0; index < resultValue.Properties.Count(); index++)
{
Assert.AreNotSame(memberDisplay.Properties.GetItemByIndex(index), resultValue.Properties.GetItemByIndex(index));
//Assert.AreEqual(memberDisplay.Properties.GetItemByIndex(index), resultValue.Properties.GetItemByIndex(index));
}
}
public void PostSaveMember_WhenModelStateIsNotValid_ExpectFailureResponse(
[Frozen] IMemberManager umbracoMembersUserManager,
IMemberService memberService,
IMemberTypeService memberTypeService,
IMemberGroupService memberGroupService,
IDataTypeService dataTypeService,
IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
IPasswordChanger <MemberIdentityUser> passwordChanger,
IOptions <GlobalSettings> globalSettings,
IUser user)
{
// arrange
Member member = SetupMemberTestData(out MemberSave fakeMemberData, out MemberDisplay memberDisplay, ContentSaveAction.SaveNew);
MemberController sut = CreateSut(memberService, memberTypeService, memberGroupService, umbracoMembersUserManager, dataTypeService, backOfficeSecurityAccessor, passwordChanger, globalSettings, user);
sut.ModelState.AddModelError("key", "Invalid model state");
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.CreateAsync(It.IsAny <MemberIdentityUser>(), It.IsAny <string>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.ValidatePasswordAsync(It.IsAny <string>()))
.ReturnsAsync(() => IdentityResult.Success);
var value = new MemberDisplay();
// act
ActionResult <MemberDisplay> result = sut.PostSave(fakeMemberData).Result;
var validation = result.Result as ValidationErrorResult;
// assert
Assert.IsNotNull(result.Result);
Assert.IsNull(result.Value);
Assert.AreEqual(StatusCodes.Status400BadRequest, validation?.StatusCode);
}
private void Map(MembershipUser source, MemberDisplay target, MapperContext context)
{
//first convert to IMember
var member = context.Map<IMember>(source);
//then convert to MemberDisplay
context.Map<IMember, MemberDisplay>(member);
}
// Umbraco.Code.MapAll -Properties -Errors -Edited -Updater -Alias -IsChildOfListView
// Umbraco.Code.MapAll -Trashed -IsContainer -VariesByCulture
private void Map(IMember source, MemberDisplay target, MapperContext context)
{
target.ContentApps = _commonMapper.GetContentApps(source);
target.ContentType = _commonMapper.GetContentType(source, context);
target.ContentTypeId = source.ContentType.Id;
target.ContentTypeAlias = source.ContentType.Alias;
target.ContentTypeName = source.ContentType.Name;
target.CreateDate = source.CreateDate;
target.Email = source.Email;
target.Icon = source.ContentType.Icon;
target.Id = source.Id;
target.Key = source.Key;
target.MemberProviderFieldMapping = GetMemberProviderFieldMapping();
target.MembershipScenario = GetMembershipScenario();
target.Name = source.Name;
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.SortOrder = source.SortOrder;
target.State = null;
target.Tabs = _tabsAndPropertiesMapper.Map(source, context);
target.TreeNodeUrl = _commonMapper.GetMemberTreeNodeUrl(source);
target.Udi = Udi.Create(Constants.UdiEntityType.Member, source.Key);
target.UpdateDate = source.UpdateDate;
target.Username = source.Username;
}
// Umbraco.Code.MapAll -Properties -Errors -Edited -Updater -Alias -IsChildOfListView
// Umbraco.Code.MapAll -Trashed -IsContainer -VariesByCulture
private void Map(IMember source, MemberDisplay target, MapperContext context)
{
target.ContentApps = _commonMapper.GetContentAppsForEntity(source);
target.ContentType = _commonMapper.GetContentType(source, context);
target.ContentTypeId = source.ContentType.Id;
target.ContentTypeAlias = source.ContentType.Alias;
target.ContentTypeName = source.ContentType.Name;
target.CreateDate = source.CreateDate;
target.Icon = source.ContentType.Icon;
target.Id = source.Id;
target.Key = source.Key;
target.Name = source.Name;
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.SortOrder = source.SortOrder;
target.State = null;
target.Tabs = _tabsAndPropertiesMapper.Map(source, context);
target.TreeNodeUrl = _commonTreeNodeMapper.GetTreeNodeUrl <MemberTreeController>(source);
target.Udi = Udi.Create(Constants.UdiEntityType.Member, source.Key);
target.UpdateDate = source.UpdateDate;
//Membership
target.Username = source.Username;
target.Email = source.Email;
target.IsLockedOut = source.IsLockedOut;
target.IsApproved = source.IsApproved;
target.MembershipProperties = _tabsAndPropertiesMapper.MapMembershipProperties(source, context);
}
/// <summary>
/// 创建单位
/// </summary>
public void CreateMember()
{
// -----------------------------数据初始化-----------------------------
// 初始化单位
RandomPacker.Single.SetSeed((int)DateTime.Now.Ticks);
var memberDisplay = new MemberDisplay(GameObject.CreatePrimitive(PrimitiveType.Sphere));
controlMember = new Member(MemberManager.Single.FrameCount, memberDisplay, MemberManager.Single, RandomPacker.Single.GetRangeI(0, 10000));
controlMember.Hp = 100;
controlMember.Speed = 1;
controlMember.IsLocal = true;
Debug.Log("单位Id" + controlMember.Id);
MemberManager.Single.Add(controlMember);
}
/// <summary>
/// 启动
/// </summary>
void Start()
{
// 设置游戏帧率
Application.targetFrameRate = 45;
RandomPacker.Single.SetSeed(RandomSeed);
// 初始化地图
var mapBase = MapManager.Single.GetMapBase(MapId, MapCenter, UnitWidth);
// 设置显示模式
MemberManager.Single.ShowMode = ShowMode;
DisplayCmdManager.Single.ShowMode = ShowMode;
// 初始化数据黑板
BlackBoard.Single.MapBase = mapBase;
MemberManager.Single.Reset();
for (var i = 0; i < MemberCount; i++)
{
// 初始化单位
var memberDisplay = new MemberDisplay(GameObject.CreatePrimitive(PrimitiveType.Capsule));
var member = new Member(MemberManager.Single.FrameCount, memberDisplay, MemberManager.Single);
member.Hp = 100;
MemberManager.Single.Add(member);
}
// 设置战斗结束检测
MemberManager.Single.SetCheckFightEndFunc((memberList) =>
{
if (memberList.Count == 0)
{
// 战斗结束
Debug.Log("战斗结束");
return(false);
}
// 战斗继续
return(true);
});
}
/// <summary>
/// Setup all standard member data for test
/// </summary>
private Member SetupMemberTestData(
out MemberSave fakeMemberData,
out MemberDisplay memberDisplay,
ContentSaveAction contentAction)
{
// arrange
MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType();
Member member = MemberBuilder.CreateSimpleMember(memberType, "Test Member", "*****@*****.**", "123", "test");
var memberId = 123;
member.Id = memberId;
// TODO: replace with builder for MemberSave and MemberDisplay
fakeMemberData = new MemberSave()
{
Id = memberId,
SortOrder = member.SortOrder,
ContentTypeId = memberType.Id,
Key = member.Key,
Password = new ChangingPasswordModel()
{
Id = 456,
NewPassword = member.RawPasswordValue,
OldPassword = null
},
Name = member.Name,
Email = member.Email,
Username = member.Username,
PersistedContent = member,
PropertyCollectionDto = new ContentPropertyCollectionDto()
{
},
Groups = new List <string>(),
//Alias = "fakeAlias",
ContentTypeAlias = member.ContentTypeAlias,
Action = contentAction,
Icon = "icon-document",
Path = member.Path
};
memberDisplay = new MemberDisplay()
{
Id = memberId,
SortOrder = member.SortOrder,
ContentTypeId = memberType.Id,
Key = member.Key,
Name = member.Name,
Email = member.Email,
Username = member.Username,
//Alias = "fakeAlias",
ContentTypeAlias = member.ContentTypeAlias,
ContentType = new ContentTypeBasic(),
ContentTypeName = member.ContentType.Name,
Icon = fakeMemberData.Icon,
Path = member.Path,
Tabs = new List <Tab <ContentPropertyDisplay> >()
{
new Tab <ContentPropertyDisplay>()
{
Alias = "test",
Id = 77,
Properties = new List <ContentPropertyDisplay>()
{
new ContentPropertyDisplay()
{
Alias = "_umb_id",
View = "idwithguid",
Value = new []
{
"123",
"guid"
}
},
new ContentPropertyDisplay()
{
Alias = "_umb_doctype"
},
new ContentPropertyDisplay()
{
Alias = "_umb_login"
},
new ContentPropertyDisplay()
{
Alias = "_umb_email"
},
new ContentPropertyDisplay()
{
Alias = "_umb_password"
},
new ContentPropertyDisplay()
{
Alias = "_umb_membergroup"
}
}
}
}
};
return(member);
}
public SendingMemberNotification(MemberDisplay member, IUmbracoContext umbracoContext)
{
Member = member;
UmbracoContext = umbracoContext;
}
/// <summary>
/// Returns the login property display field
/// </summary>
/// <param name="memberService"></param>
/// <param name="member"></param>
/// <param name="display"></param>
/// <returns></returns>
/// <remarks>
/// If the membership provider installed is the umbraco membership provider, then we will allow changing the username, however if
/// the membership provider is a custom one, we cannot allow chaning the username because MembershipProvider's do not actually natively
/// allow that.
/// </remarks>
internal static ContentPropertyDisplay GetLoginProperty(IMemberService memberService, IMember member, MemberDisplay display)
{
var prop = new ContentPropertyDisplay
{
Alias = string.Format("{0}login", Constants.PropertyEditors.InternalGenericPropertiesPrefix),
Label = ui.Text("login"),
Value = display.Username
};
var scenario = memberService.GetMembershipScenario();
//only allow editing if this is a new member, or if the membership provider is the umbraco one
if (member.HasIdentity == false || scenario == MembershipScenario.NativeUmbraco)
{
prop.View = "textbox";
prop.Validation.Mandatory = true;
}
else
{
prop.View = "readonlyvalue";
}
return(prop);
}
/// <summary>
/// Maps the generic tab with custom properties for content
/// </summary>
/// <param name="memberService"></param>
/// <param name="member"></param>
/// <param name="display"></param>
/// <remarks>
/// If this is a new entity and there is an approved field then we'll set it to true by default.
/// </remarks>
private static void MapGenericCustomProperties(IMemberService memberService, IMember member, MemberDisplay display)
{
var membersProvider = Core.Security.MembershipProviderExtensions.GetMembersMembershipProvider();
//map the tree node url
if (HttpContext.Current != null)
{
var urlHelper = new UrlHelper(new RequestContext(new HttpContextWrapper(HttpContext.Current), new RouteData()));
var url = urlHelper.GetUmbracoApiService <MemberTreeController>(controller => controller.GetTreeNode(display.Key.ToString("N"), null));
display.TreeNodeUrl = url;
}
var genericProperties = new List <ContentPropertyDisplay>
{
GetLoginProperty(memberService, member, display),
new ContentPropertyDisplay
{
Alias = string.Format("{0}email", Constants.PropertyEditors.InternalGenericPropertiesPrefix),
Label = ui.Text("general", "email"),
Value = display.Email,
View = "email",
Validation = { Mandatory = true }
},
new ContentPropertyDisplay
{
Alias = string.Format("{0}password", Constants.PropertyEditors.InternalGenericPropertiesPrefix),
Label = ui.Text("password"),
//NOTE: The value here is a json value - but the only property we care about is the generatedPassword one if it exists, the newPassword exists
// only when creating a new member and we want to have a generated password pre-filled.
Value = new Dictionary <string, object>
{
{ "generatedPassword", member.GetAdditionalDataValueIgnoreCase("GeneratedPassword", null) },
{ "newPassword", member.GetAdditionalDataValueIgnoreCase("NewPassword", null) },
},
//TODO: Hard coding this because the changepassword doesn't necessarily need to be a resolvable (real) property editor
View = "changepassword",
//initialize the dictionary with the configuration from the default membership provider
Config = new Dictionary <string, object>(membersProvider.GetConfiguration())
{
//the password change toggle will only be displayed if there is already a password assigned.
{ "hasPassword", member.RawPasswordValue.IsNullOrWhiteSpace() == false }
}
},
new ContentPropertyDisplay
{
Alias = string.Format("{0}membergroup", Constants.PropertyEditors.InternalGenericPropertiesPrefix),
Label = ui.Text("content", "membergroup"),
Value = GetMemberGroupValue(display.Username),
View = "membergroups",
Config = new Dictionary <string, object> {
{ "IsRequired", true }
}
}
};
TabsAndPropertiesResolver.MapGenericProperties(member, display, genericProperties);
//check if there's an approval field
var provider = membersProvider as global::umbraco.providers.members.UmbracoMembershipProvider;
if (member.HasIdentity == false && provider != null)
{
var approvedField = provider.ApprovedPropertyTypeAlias;
var prop = display.Properties.FirstOrDefault(x => x.Alias == approvedField);
if (prop != null)
{
prop.Value = 1;
}
}
}
/// <summary>
/// Create a member from the supplied member content data
///
/// All member password processing and creation is done via the identity manager
/// </summary>
/// <param name="contentItem">Member content data</param>
/// <returns>The identity result of the created member</returns>
private async Task <ActionResult <bool> > CreateMemberAsync(MemberSave contentItem)
{
IMemberType memberType = _memberTypeService.Get(contentItem.ContentTypeAlias);
if (memberType == null)
{
throw new InvalidOperationException($"No member type found with alias {contentItem.ContentTypeAlias}");
}
var identityMember = MemberIdentityUser.CreateNew(
contentItem.Username,
contentItem.Email,
memberType.Alias,
contentItem.IsApproved,
contentItem.Name);
IdentityResult created = await _memberManager.CreateAsync(identityMember, contentItem.Password.NewPassword);
if (created.Succeeded == false)
{
MemberDisplay forDisplay = _umbracoMapper.Map <MemberDisplay>(contentItem.PersistedContent);
foreach (IdentityError error in created.Errors)
{
switch (error.Code)
{
case nameof(IdentityErrorDescriber.InvalidUserName):
ModelState.AddPropertyError(
new ValidationResult(error.Description, new[] { "value" }),
string.Format("{0}login", Constants.PropertyEditors.InternalGenericPropertiesPrefix));
break;
case nameof(IdentityErrorDescriber.PasswordMismatch):
case nameof(IdentityErrorDescriber.PasswordRequiresDigit):
case nameof(IdentityErrorDescriber.PasswordRequiresLower):
case nameof(IdentityErrorDescriber.PasswordRequiresNonAlphanumeric):
case nameof(IdentityErrorDescriber.PasswordRequiresUniqueChars):
case nameof(IdentityErrorDescriber.PasswordRequiresUpper):
case nameof(IdentityErrorDescriber.PasswordTooShort):
ModelState.AddPropertyError(
new ValidationResult(error.Description, new[] { "value" }),
string.Format("{0}password", Constants.PropertyEditors.InternalGenericPropertiesPrefix));
break;
case nameof(IdentityErrorDescriber.InvalidEmail):
ModelState.AddPropertyError(
new ValidationResult(error.Description, new[] { "value" }),
string.Format("{0}email", Constants.PropertyEditors.InternalGenericPropertiesPrefix));
break;
case nameof(IdentityErrorDescriber.DuplicateUserName):
ModelState.AddPropertyError(
new ValidationResult(error.Description, new[] { "value" }),
string.Format("{0}login", Constants.PropertyEditors.InternalGenericPropertiesPrefix));
break;
case nameof(IdentityErrorDescriber.DuplicateEmail):
ModelState.AddPropertyError(
new ValidationResult(error.Description, new[] { "value" }),
string.Format("{0}email", Constants.PropertyEditors.InternalGenericPropertiesPrefix));
break;
}
}
return(ValidationProblem(forDisplay, ModelState));
}
// now re-look up the member, which will now exist
IMember member = _memberService.GetByEmail(contentItem.Email);
// map the save info over onto the user
member = _umbracoMapper.Map <MemberSave, IMember>(contentItem, member);
int creatorId = _backOfficeSecurityAccessor.BackOfficeSecurity.CurrentUser.Id;
member.CreatorId = creatorId;
// assign the mapped property values that are not part of the identity properties
string[] builtInAliases = ConventionsHelper.GetStandardPropertyTypeStubs(_shortStringHelper).Select(x => x.Key).ToArray();
foreach (ContentPropertyBasic property in contentItem.Properties)
{
if (builtInAliases.Contains(property.Alias) == false)
{
member.Properties[property.Alias].SetValue(property.Value);
}
}
// now the member has been saved via identity, resave the member with mapped content properties
_memberService.Save(member);
contentItem.PersistedContent = member;
ActionResult <bool> rolesChanged = await AddOrUpdateRoles(contentItem.Groups, identityMember);
if (!rolesChanged.Value && rolesChanged.Result != null)
{
return(rolesChanged.Result);
}
return(true);
}
public async Task <ActionResult <MemberDisplay> > PostSave([ModelBinder(typeof(MemberBinder))] MemberSave contentItem)
{
if (contentItem == null)
{
throw new ArgumentNullException("The member content item was null");
}
// If we've reached here it means:
// * Our model has been bound
// * and validated
// * any file attachments have been saved to their temporary location for us to use
// * we have a reference to the DTO object and the persisted object
// * Permissions are valid
// map the properties to the persisted entity
MapPropertyValues(contentItem);
await ValidateMemberDataAsync(contentItem);
// Unlike content/media - if there are errors for a member, we do NOT proceed to save them, we cannot so return the errors
if (ModelState.IsValid == false)
{
MemberDisplay forDisplay = _umbracoMapper.Map <MemberDisplay>(contentItem.PersistedContent);
return(ValidationProblem(forDisplay, ModelState));
}
// Create a scope here which will wrap all child data operations in a single transaction.
// We'll complete this at the end of this method if everything succeeeds, else
// all data operations will roll back.
using IScope scope = _scopeProvider.CreateScope();
// Depending on the action we need to first do a create or update using the membership manager
// this ensures that passwords are formatted correctly and also performs the validation on the provider itself.
switch (contentItem.Action)
{
case ContentSaveAction.Save:
ActionResult <bool> updateSuccessful = await UpdateMemberAsync(contentItem);
if (!(updateSuccessful.Result is null))
{
return(updateSuccessful.Result);
}
break;
case ContentSaveAction.SaveNew:
ActionResult <bool> createSuccessful = await CreateMemberAsync(contentItem);
if (!(createSuccessful.Result is null))
{
return(createSuccessful.Result);
}
break;
default:
// we don't support anything else for members
return(NotFound());
}
// return the updated model
MemberDisplay display = _umbracoMapper.Map <MemberDisplay>(contentItem.PersistedContent);
// lastly, if it is not valid, add the model state to the outgoing object and throw a 403
if (!ModelState.IsValid)
{
return(ValidationProblem(display, ModelState, StatusCodes.Status403Forbidden));
}
// put the correct messages in
switch (contentItem.Action)
{
case ContentSaveAction.Save:
case ContentSaveAction.SaveNew:
display.AddSuccessNotification(
_localizedTextService.Localize("speechBubbles", "editMemberSaved"),
_localizedTextService.Localize("speechBubbles", "editMemberSaved"));
break;
}
// Mark transaction to commit all changes
scope.Complete();
return(display);
}
/// <summary>
/// Setup all standard member data for test
/// </summary>
private Member SetupMemberTestData(
out MemberSave fakeMemberData,
out MemberDisplay memberDisplay,
ContentSaveAction contentAction)
{
// arrange
var memberType = MemberTypeBuilder.CreateSimpleMemberType();
var member = MemberBuilder.CreateSimpleMember(memberType, "Test Member", "*****@*****.**", "123", "test");
var memberId = 123;
member.Id = memberId;
// TODO: replace with builder for MemberSave and MemberDisplay
fakeMemberData = new MemberSave
{
Id = memberId,
SortOrder = member.SortOrder,
ContentTypeId = memberType.Id,
Key = member.Key,
Password = new ChangingPasswordModel {
Id = 456, NewPassword = member.RawPasswordValue, OldPassword = null
},
Name = member.Name,
Email = member.Email,
Username = member.Username,
PersistedContent = member,
PropertyCollectionDto = new ContentPropertyCollectionDto(),
Groups = new List <string>(),
// Alias = "fakeAlias",
ContentTypeAlias = member.ContentTypeAlias,
Action = contentAction,
Icon = "icon-document",
Path = member.Path,
};
memberDisplay = new MemberDisplay
{
Id = memberId,
SortOrder = member.SortOrder,
ContentTypeId = memberType.Id,
Key = member.Key,
Name = member.Name,
Email = member.Email,
Username = member.Username,
// Alias = "fakeAlias",
ContentTypeAlias = member.ContentTypeAlias,
ContentType = new ContentTypeBasic(),
ContentTypeName = member.ContentType.Name,
Icon = fakeMemberData.Icon,
Path = member.Path,
Tabs = new List <Tab <ContentPropertyDisplay> >
{
new()
{
Alias = "test",
Id = 77,
Properties = new List <ContentPropertyDisplay>
{
new() { Alias = $"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}login" },
new() { Alias = $"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}email" },
new()
{
Alias =
$"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}password",
},
new()
{
Alias =
$"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}membergroup",
},
new()
{
Alias =
$"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}failedPasswordAttempts",
},
new()
{
Alias =
$"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}approved",
},
new()
{
Alias =
$"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}lockedOut",
},
new()
{
Alias =
$"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}lastLockoutDate",
},
new()
{
Alias =
$"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}lastLoginDate",
},
new()
{
Alias =
$"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}lastPasswordChangeDate",
},
},
},
},
};
return(member);
}
/// <summary>
/// Maps the generic tab with custom properties for content
/// </summary>
/// <param name="memberService"></param>
/// <param name="userService"></param>
/// <param name="member"></param>
/// <param name="display"></param>
/// <param name="localizedText"></param>
/// <remarks>
/// If this is a new entity and there is an approved field then we'll set it to true by default.
/// </remarks>
private static void MapGenericCustomProperties(IMemberService memberService, IUserService userService, IMember member, MemberDisplay display, ILocalizedTextService localizedText)
{
var membersProvider = Core.Security.MembershipProviderExtensions.GetMembersMembershipProvider();
//map the tree node url
if (HttpContext.Current != null)
{
var urlHelper = new UrlHelper(HttpContext.Current.Request.RequestContext);
var url = urlHelper.GetUmbracoApiService <MemberTreeController>(controller => controller.GetTreeNode(display.Key.ToString("N"), null));
display.TreeNodeUrl = url;
}
var genericProperties = new List <ContentPropertyDisplay>
{
new ContentPropertyDisplay
{
Alias = string.Format("{0}doctype", Constants.PropertyEditors.InternalGenericPropertiesPrefix),
Label = localizedText.Localize("content/membertype"),
Value = localizedText.UmbracoDictionaryTranslate(display.ContentTypeName),
View = PropertyEditorResolver.Current.GetByAlias(Constants.PropertyEditors.NoEditAlias).ValueEditor.View
},
GetLoginProperty(memberService, member, display, localizedText),
new ContentPropertyDisplay
{
Alias = string.Format("{0}email", Constants.PropertyEditors.InternalGenericPropertiesPrefix),
Label = localizedText.Localize("general/email"),
Value = display.Email,
View = "email",
Validation = { Mandatory = true }
},
new ContentPropertyDisplay
{
Alias = string.Format("{0}password", Constants.PropertyEditors.InternalGenericPropertiesPrefix),
Label = localizedText.Localize("password"),
//NOTE: The value here is a json value - but the only property we care about is the generatedPassword one if it exists, the newPassword exists
// only when creating a new member and we want to have a generated password pre-filled.
Value = new Dictionary <string, object>
{
{ "generatedPassword", member.GetAdditionalDataValueIgnoreCase("GeneratedPassword", null) },
{ "newPassword", member.GetAdditionalDataValueIgnoreCase("NewPassword", null) },
},
//TODO: Hard coding this because the changepassword doesn't necessarily need to be a resolvable (real) property editor
View = "changepassword",
//initialize the dictionary with the configuration from the default membership provider
Config = new Dictionary <string, object>(membersProvider.GetConfiguration(userService))
{
//the password change toggle will only be displayed if there is already a password assigned.
{ "hasPassword", member.RawPasswordValue.IsNullOrWhiteSpace() == false }
}
},
new ContentPropertyDisplay
{
Alias = string.Format("{0}membergroup", Constants.PropertyEditors.InternalGenericPropertiesPrefix),
Label = localizedText.Localize("content/membergroup"),
Value = GetMemberGroupValue(display.Username),
View = "membergroups",
Config = new Dictionary <string, object> {
{ "IsRequired", true }
}
}
};
TabsAndPropertiesResolver.MapGenericProperties(member, display, localizedText, genericProperties, properties =>
{
if (HttpContext.Current != null && UmbracoContext.Current != null && UmbracoContext.Current.Security.CurrentUser != null &&
UmbracoContext.Current.Security.CurrentUser.AllowedSections.Any(x => x.Equals(Constants.Applications.Settings)))
{
var memberTypeLink = string.Format("#/member/memberTypes/edit/{0}", member.ContentTypeId);
//Replace the doctype property
var docTypeProperty = properties.First(x => x.Alias == string.Format("{0}doctype", Constants.PropertyEditors.InternalGenericPropertiesPrefix));
docTypeProperty.Value = new List <object>
{
new
{
linkText = member.ContentType.Name,
url = memberTypeLink,
target = "_self",
icon = "icon-item-arrangement"
}
};
docTypeProperty.View = "urllist";
}
});
//check if there's an approval field
var provider = membersProvider as global::umbraco.providers.members.UmbracoMembershipProvider;
if (member.HasIdentity == false && provider != null)
{
var approvedField = provider.ApprovedPropertyTypeAlias;
var prop = display.Properties.FirstOrDefault(x => x.Alias == approvedField);
if (prop != null)
{
prop.Value = 1;
}
}
}
