internal void InitFrontManager(
Mock <IMemberRepository> memberRepo,
Mock <IPhotoRepository> photoRepo)
{
this.MockFrontManager = new FrontManager(
photoRepo?.Object,
this._mockMapper.Object);
this.MockMemberManager = new MemberManager(
this._mockPasswordManager.Object,
this._mockTokenManager.Object,
this._mockMapper.Object,
memberRepo?.Object);
}
public async Task PostSaveMember_SaveNew_CustomField_WhenAllIsSetupCorrectly_ExpectSuccessResponse(
[Frozen] IMemberManager umbracoMembersUserManager,
IMemberService memberService,
IMemberTypeService memberTypeService,
IMemberGroupService memberGroupService,
IDataTypeService dataTypeService,
IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
IBackOfficeSecurity backOfficeSecurity,
IPasswordChanger <MemberIdentityUser> passwordChanger,
IOptions <GlobalSettings> globalSettings,
IUser user)
{
// arrange
var member = SetupMemberTestData(out var fakeMemberData, out var memberDisplay, ContentSaveAction.SaveNew);
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);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.GetRolesAsync(It.IsAny <MemberIdentityUser>()))
.ReturnsAsync(() => Array.Empty <string>());
Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
Mock.Get(backOfficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(backOfficeSecurity);
Mock.Get(memberService).SetupSequence(
x => x.GetByEmail(It.IsAny <string>()))
.Returns(() => null)
.Returns(() => member);
Mock.Get(memberService).Setup(x => x.GetByUsername(It.IsAny <string>())).Returns(() => member);
var sut = CreateSut(
memberService,
memberTypeService,
memberGroupService,
umbracoMembersUserManager,
dataTypeService,
backOfficeSecurityAccessor,
passwordChanger,
globalSettings);
// act
var result = await sut.PostSave(fakeMemberData);
// assert
Assert.IsNull(result.Result);
Assert.IsNotNull(result.Value);
AssertMemberDisplayPropertiesAreEqual(memberDisplay, result.Value);
}
public async Task PostSaveMember_SaveExisting_WhenAllIsSetupCorrectly_ExpectSuccessResponse(
[Frozen] IMemberManager umbracoMembersUserManager,
IMemberService memberService,
IMemberTypeService memberTypeService,
IMemberGroupService memberGroupService,
IDataTypeService dataTypeService,
IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
IBackOfficeSecurity backOfficeSecurity,
IPasswordChanger <MemberIdentityUser> passwordChanger,
IOptions <GlobalSettings> globalSettings,
IUser user)
{
// arrange
Member member = SetupMemberTestData(out MemberSave fakeMemberData, out MemberDisplay memberDisplay, ContentSaveAction.Save);
var membersIdentityUser = new MemberIdentityUser(123);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.FindByIdAsync(It.IsAny <string>()))
.ReturnsAsync(() => membersIdentityUser);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.ValidatePasswordAsync(It.IsAny <string>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.UpdateAsync(It.IsAny <MemberIdentityUser>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
Mock.Get(globalSettings);
SetupUserAccess(backOfficeSecurityAccessor, backOfficeSecurity, user);
SetupPasswordSuccess(umbracoMembersUserManager, passwordChanger);
Mock.Get(memberService).Setup(x => x.GetByUsername(It.IsAny <string>())).Returns(() => member);
Mock.Get(memberService).Setup(x => x.GetById(It.IsAny <int>())).Returns(() => member);
Mock.Get(memberService).SetupSequence(
x => x.GetByEmail(It.IsAny <string>()))
.Returns(() => null)
.Returns(() => member);
MemberController sut = CreateSut(memberService, memberTypeService, memberGroupService, umbracoMembersUserManager, dataTypeService, backOfficeSecurityAccessor, passwordChanger, globalSettings, user);
// act
ActionResult <MemberDisplay> result = await sut.PostSave(fakeMemberData);
// assert
Assert.IsNull(result.Result);
Assert.IsNotNull(result.Value);
AssertMemberDisplayPropertiesAreEqual(memberDisplay, result.Value);
}
public async Task GivenMemberNotLoggedIn_WhenMemberIsRequested_AndIsNull_ThenNotLoggedInResult(
IMemberManager memberManager,
IPublicAccessService publicAccessService,
IContentService contentService)
{
PublicAccessChecker sut = CreateSut(memberManager, publicAccessService, contentService, out HttpContext httpContext);
httpContext.User = GetLoggedInUser();
MockGetUserAsync(memberManager, null);
var result = await sut.HasMemberAccessToContentAsync(123);
Assert.AreEqual(PublicAccessStatus.NotLoggedIn, result);
}
// private readonly IPasswordHasher<MemberModel> _pwdHasher;
public WeixinGetUserInfoAttribute(
DbContext db,
// IHttpContextAccessor contextAccessor,
ILoggerFactory loggerFactory,
IMemberManager <MemberModel> memberManager)
{
_db = db;
// _commonContext = new CommonContext(contextAccessor);
//_weixinService = _commonContext.GetService<IWeixinApiService>();
//_weixinSetting = _commonContext.GetService<IOptions<WeixinSettings>>().Value;
//_logger = _commonContext.CreateLogger<WeixinGetUserInfoAttribute>();
//_pwdHasher = new PasswordHasher<MemberModel>();
//_memberManager = memberManager;
}
// private readonly IPasswordHasher<MemberModel> _pwdHasher;
public WeixinGetOpenIDAttribute(
DbContext db,
// IOptions<WeixinSettings> weixinSetting,
ILoggerFactory loggerFactory,
IWeixinApiService weixinService,
IMemberManager <MemberModel> memberManager)
{
_db = db;
_weixinService = weixinService;
// _weixinSetting = weixinSetting.Value;
_logger = loggerFactory.CreateLogger <WeixinGetUserInfoAttribute>();
// _pwdHasher = new PasswordHasher<MemberModel>();
_memberManager = memberManager;
}
public async Task GivenMemberNotLoggedIn_WhenIdentityIsChecked_ThenNotLoggedInResult(
IMemberManager memberManager,
IPublicAccessService publicAccessService,
IContentService contentService)
{
PublicAccessChecker sut = CreateSut(memberManager, publicAccessService, contentService, out HttpContext httpContext);
httpContext.User = new ClaimsPrincipal();
MockGetUserAsync(memberManager, new MemberIdentityUser());
var result = await sut.HasMemberAccessToContentAsync(123);
Assert.AreEqual(PublicAccessStatus.NotLoggedIn, result);
}
private IHttpContextAccessor GetHttpContextAccessor(IMemberManager memberManager, out HttpContext httpContext)
{
var services = new ServiceCollection();
services.AddScoped <IMemberManager>(x => memberManager);
httpContext = new DefaultHttpContext
{
RequestServices = services.BuildServiceProvider()
};
HttpContext localHttpContext = httpContext;
return(Mock.Of <IHttpContextAccessor>(x => x.HttpContext == localHttpContext));
}
/// <summary>
/// 实例化
/// </summary>
/// <param name="nowFrame"></param>
public Member(long nowFrame, IMemberDisplay displayMember, IMemberManager memberManager, int id = -1)
{
actionFrame = nowFrame;
DisplayMember = displayMember;
MemberManager = memberManager;
if (id < 0)
{
Id = idSeed++;
}
else
{
Id = id;
}
}
public void PostSaveMember_SaveNew_WhenMemberEmailAlreadyExists_ExpectFailResponse(
[Frozen] IMemberManager umbracoMembersUserManager,
IMemberService memberService,
IMemberTypeService memberTypeService,
IMemberGroupService memberGroupService,
IDataTypeService dataTypeService,
IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
IBackOfficeSecurity backOfficeSecurity,
IPasswordChanger <MemberIdentityUser> passwordChanger,
IOptions <GlobalSettings> globalSettings,
IUser user)
{
// arrange
var member = SetupMemberTestData(out var fakeMemberData, out _, ContentSaveAction.SaveNew);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.CreateAsync(It.IsAny <MemberIdentityUser>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(memberTypeService).Setup(x => x.GetDefault()).Returns("fakeAlias");
Mock.Get(backOfficeSecurityAccessor).Setup(x => x.BackOfficeSecurity).Returns(backOfficeSecurity);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.ValidatePasswordAsync(It.IsAny <string>()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(umbracoMembersUserManager)
.Setup(x => x.AddToRolesAsync(It.IsAny <MemberIdentityUser>(), It.IsAny <IEnumerable <string> >()))
.ReturnsAsync(() => IdentityResult.Success);
Mock.Get(memberService).SetupSequence(
x => x.GetByEmail(It.IsAny <string>()))
.Returns(() => member);
var sut = CreateSut(
memberService,
memberTypeService,
memberGroupService,
umbracoMembersUserManager,
dataTypeService,
backOfficeSecurityAccessor,
passwordChanger,
globalSettings);
// act
var 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);
}
public UmbLoginController(
IUmbracoContextAccessor umbracoContextAccessor,
IUmbracoDatabaseFactory databaseFactory,
ServiceContext services,
AppCaches appCaches,
IProfilingLogger profilingLogger,
IPublishedUrlProvider publishedUrlProvider,
IMemberSignInManager signInManager,
IMemberManager memberManager,
ITwoFactorLoginService twoFactorLoginService)
: base(umbracoContextAccessor, databaseFactory, services, appCaches, profilingLogger, publishedUrlProvider)
{
_signInManager = signInManager;
_memberManager = memberManager;
_twoFactorLoginService = twoFactorLoginService;
}
public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
{
// Allow Anonymous skips all authorization
if (HasAllowAnonymous(context))
{
return;
}
IMemberManager memberManager = context.HttpContext.RequestServices.GetRequiredService <IMemberManager>();
if (!await IsAuthorizedAsync(memberManager))
{
context.HttpContext.SetReasonPhrase("Resource restricted: either member is not logged on or is not of a permitted type or group.");
context.Result = new ForbidResult();
}
}
/// <summary>
/// Author: Matt LaMarche
/// Created : 1/26/2019
/// This constructor is used for Reading and Updating a Reservation
/// </summary>
/// <param name="existingReservation">
/// A Reservation which already exists, presumably obtained from a list of Reservations
/// </param>
public CreateReservation(Reservation existingReservation, IReservationManager reservationManager)
{
InitializeComponent();
_reservationManager = reservationManager;
_memberManager = new MemberManagerMSSQL();
try
{
_members = _memberManager.RetrieveAllMembers();
}
catch (Exception ex)
{
SetError(ex.Message);
}
//txtMembers.ItemsSource = _members;
_existingReservation = existingReservation;
populateFormReadOnly();
}
// gets this macro content cache identifier
private async Task <string> GetContentCacheIdentifier(MacroModel model, int pageId, string cultureName)
{
var id = new StringBuilder();
var alias = model.Alias;
id.AppendFormat("{0}-", alias);
// always add current culture to the key to allow variants to have different cache results
if (!string.IsNullOrEmpty(cultureName))
{
// are there any unusual culture formats we'd need to handle?
id.AppendFormat("{0}-", cultureName);
}
if (model.CacheByPage)
{
id.AppendFormat("{0}-", pageId);
}
if (model.CacheByMember)
{
object key = 0;
if (_httpContextAccessor.HttpContext?.User.Identity?.IsAuthenticated ?? false)
{
IMemberManager memberManager =
_httpContextAccessor.HttpContext.RequestServices.GetRequiredService <IMemberManager>();
MemberIdentityUser?member = await memberManager.GetCurrentMemberAsync();
if (member is not null)
{
key = member.Key;
}
}
id.AppendFormat("m{0}-", key);
}
foreach (var value in model.Properties.Select(x => x.Value))
{
id.AppendFormat("{0}-", value?.Length <= 255 ? value : value?.Substring(0, 255));
}
return(id.ToString());
}
public async Task GivenMemberLoggedIn_WhenMemberIsNotApproved_ThenNotApprovedResult(
IMemberManager memberManager,
IPublicAccessService publicAccessService,
IContentService contentService)
{
PublicAccessChecker sut = CreateSut(memberManager, publicAccessService, contentService, out HttpContext httpContext);
httpContext.User = GetLoggedInUser();
MockGetUserAsync(memberManager, new MemberIdentityUser {
IsApproved = false
});
MockGetRolesAsync(memberManager);
var result = await sut.HasMemberAccessToContentAsync(123);
Assert.AreEqual(PublicAccessStatus.NotApproved, result);
}
public async Task GivenMemberLoggedIn_WhenMemberIsLockedOut_ThenLockedOutResult(
IMemberManager memberManager,
IPublicAccessService publicAccessService,
IContentService contentService)
{
PublicAccessChecker sut = CreateSut(memberManager, publicAccessService, contentService, out HttpContext httpContext);
httpContext.User = GetLoggedInUser();
MockGetUserAsync(memberManager, new MemberIdentityUser {
IsApproved = true, LockoutEnd = DateTime.UtcNow.AddDays(10)
});
MockGetRolesAsync(memberManager);
var result = await sut.HasMemberAccessToContentAsync(123);
Assert.AreEqual(PublicAccessStatus.LockedOut, result);
}
public async Task GivenMemberLoggedIn_WhenMemberHasRoles_AndContentDoesNotExist_ThenAccessAcceptedResult(
IMemberManager memberManager,
IPublicAccessService publicAccessService,
IContentService contentService)
{
PublicAccessChecker sut = CreateSut(memberManager, publicAccessService, contentService, out HttpContext httpContext);
httpContext.User = GetLoggedInUser();
MockGetUserAsync(memberManager, new MemberIdentityUser {
IsApproved = true
});
MockGetRolesAsync(memberManager);
Mock.Get(contentService).Setup(x => x.GetById(123)).Returns((IContent)null);
var result = await sut.HasMemberAccessToContentAsync(123);
Assert.AreEqual(PublicAccessStatus.AccessAccepted, result);
}
private void button1_Click(object sender, EventArgs e)
{
IMemberManager imm = ManagerFactory.getMememberManager("MemberMangerImpl");
IQueryManager iqm = ManagerFactory.getQueryManager("QUeryManagerImpl");
Partner partner = new Partner();
partner.Name = PartnerName.Text;
if (Male.Checked)
{
partner.Sex = '男';
}
else
{
partner.Sex = '女';
}
partner.Partnerid = iqm.queryUser(username).Memberid;
imm.addPartner(partner);
}
/// <summary>
/// Author: Matt LaMarche
/// Created : 1/24/2019
/// This constructor is used for Creating a Reservation
/// Initializes connections to our ReservationManager and MemberManager
/// Populates Member Combobox and displays any errors
/// </summary>
public CreateReservation(IReservationManager reservationManager)
{
InitializeComponent();
_reservationManager = reservationManager;
_memberManager = new MemberManagerMSSQL();
try
{
_members = _memberManager.RetrieveAllMembers();
}
catch (Exception ex)
{
SetError(ex.Message);
}
//txtMembers.ItemsSource = _members;
chkActive.Visibility = Visibility.Hidden;
chkActive.IsChecked = true;
_existingReservation = null;
}
public UmbRegisterController(
IMemberManager memberManager,
IMemberService memberService,
IUmbracoContextAccessor umbracoContextAccessor,
IUmbracoDatabaseFactory databaseFactory,
ServiceContext services,
AppCaches appCaches,
IProfilingLogger profilingLogger,
IPublishedUrlProvider publishedUrlProvider,
IMemberSignInManager memberSignInManager,
ICoreScopeProvider scopeProvider)
: base(umbracoContextAccessor, databaseFactory, services, appCaches, profilingLogger, publishedUrlProvider)
{
_memberManager = memberManager;
_memberService = memberService;
_memberSignInManager = memberSignInManager;
_scopeProvider = scopeProvider;
}
public async Task GivenMemberLoggedIn_WhenMemberHasRoles_AndRoleRuleMatches_ThenAccessAcceptedResult(
IMemberManager memberManager,
IPublicAccessService publicAccessService,
IContentService contentService,
IContent content)
{
PublicAccessChecker sut = CreateSut(memberManager, publicAccessService, contentService, out HttpContext httpContext);
httpContext.User = GetLoggedInUser();
MockGetUserAsync(memberManager, new MemberIdentityUser {
UserName = "******", IsApproved = true
});
MockGetRolesAsync(memberManager);
Mock.Get(contentService).Setup(x => x.GetById(123)).Returns(content);
Mock.Get(publicAccessService).Setup(x => x.GetEntryForContent(content)).Returns(GetPublicAccessEntry(string.Empty, "role1"));
var result = await sut.HasMemberAccessToContentAsync(123);
Assert.AreEqual(PublicAccessStatus.AccessAccepted, result);
}
public UmbExternalLoginController(
IUmbracoContextAccessor umbracoContextAccessor,
IUmbracoDatabaseFactory databaseFactory,
ServiceContext services,
AppCaches appCaches,
IProfilingLogger profilingLogger,
IPublishedUrlProvider publishedUrlProvider,
IMemberSignInManagerExternalLogins memberSignInManager,
IMemberManager memberManager)
: base(
umbracoContextAccessor,
databaseFactory,
services,
appCaches,
profilingLogger,
publishedUrlProvider)
{
_memberSignInManager = memberSignInManager;
_memberManager = memberManager;
}
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
SetupMemberTestData(out var fakeMemberData, out _, ContentSaveAction.SaveNew);
var sut = CreateSut(
memberService,
memberTypeService,
memberGroupService,
umbracoMembersUserManager,
dataTypeService,
backOfficeSecurityAccessor,
passwordChanger,
globalSettings);
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);
// act
var 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 button1_Click(object sender, EventArgs e)
{
IMemberManager imm = ManagerFactory.getMememberManager("MemberMangerImpl");
IQueryManager iqm = ManagerFactory.getQueryManager("QUeryManagerImpl");
string name = MemberName.Text.Trim();
Member member = iqm.queryMember(name);
Member m = iqm.getAncestor(member.Mapid);
if (member == null)
{
MessageBox.Show("该成员不存在！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
if (member.Id == m.Id)
{
MessageBox.Show("该成员为该族谱祖先，不能删除！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
imm.deleteMember(MemberName.Text.Trim());
MessageBox.Show("删除成功！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public ExtendedMemberController(
ICultureDictionary cultureDictionary,
ILoggerFactory loggerFactory,
IShortStringHelper shortStringHelper,
IEventMessagesFactory eventMessages,
ILocalizedTextService localizedTextService,
PropertyEditorCollection propertyEditors,
IUmbracoMapper umbracoMapper,
IMemberService memberService,
IMemberTypeService memberTypeService,
IMemberManager memberManager,
IDataTypeService dataTypeService,
IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
IJsonSerializer jsonSerializer,
IPasswordChanger <MemberIdentityUser> passwordChanger,
IScopeProvider scopeProvider,
IMemberExtendedService memberExtendedService,
IMemberGroupService memberGroupService,
IConfiguration configuration) :
base(cultureDictionary, loggerFactory, shortStringHelper, eventMessages, localizedTextService,
propertyEditors, umbracoMapper, memberService, memberTypeService,
memberManager, dataTypeService, backOfficeSecurityAccessor, jsonSerializer, passwordChanger, scopeProvider)
private void button1_Click(object sender, EventArgs e)
{
Member member = new Member();
Member m = new Member();
IMemberManager imm = ManagerFactory.getMememberManager("MemberMangerImpl");
IQueryManager iqm = ManagerFactory.getQueryManager("QUeryManagerImpl");
m = iqm.queryMember(FatherName.Text.Trim());
if (m == null)
{
MessageBox.Show("您输入的成员父亲在族谱中不存在！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
StringBuilder sb = new StringBuilder();
member.Name = MemberName.Text.Trim();
member.Fatherid = m.Id;
sb.Append(Year.GetItemText(Year.Items[0]));
sb.Append("/");
sb.Append(Month.GetItemText(Month.Items[0]));
sb.Append("/");
sb.Append(Day.GetItemText(Day.Items[0]));
//MessageBox.Show(sb.ToString());
member.Birth = sb.ToString();
member.BirthPlace = BirthPlace.Text;
member.Generation = Generation.Text.Trim();
member.Idcard = Idcard.Text;
if (Male.Checked)
{
member.Sex = '男';
}
else
{
member.Sex = '女';
}
member.Mapid = m.Mapid;
imm.addMember(member);
MessageBox.Show("添加成功！");
}
private static void SetupPasswordSuccess(IMemberManager umbracoMembersUserManager, IPasswordChanger <MemberIdentityUser> passwordChanger, bool successful = true)
{
var passwordChanged = new PasswordChangedModel()
{
ChangeError = null,
ResetPassword = null
};
if (!successful)
{
var attempt = Attempt.Fail <PasswordChangedModel>(passwordChanged);
Mock.Get(passwordChanger)
.Setup(x => x.ChangePasswordWithIdentityAsync(It.IsAny <ChangingPasswordModel>(), umbracoMembersUserManager))
.ReturnsAsync(() => attempt);
}
else
{
var attempt = Attempt.Succeed <PasswordChangedModel>(passwordChanged);
Mock.Get(passwordChanger)
.Setup(x => x.ChangePasswordWithIdentityAsync(It.IsAny <ChangingPasswordModel>(), umbracoMembersUserManager))
.ReturnsAsync(() => attempt);
}
}
public async Task <PublicAccessStatus> HasMemberAccessToContentAsync(int publishedContentId)
{
HttpContext httpContext = _httpContextAccessor.GetRequiredHttpContext();
IMemberManager memberManager = httpContext.RequestServices.GetRequiredService <IMemberManager>();
if (httpContext.User.Identity == null || !httpContext.User.Identity.IsAuthenticated)
{
return(PublicAccessStatus.NotLoggedIn);
}
MemberIdentityUser?currentMember = await memberManager.GetUserAsync(httpContext.User);
if (currentMember == null)
{
return(PublicAccessStatus.NotLoggedIn);
}
var username = currentMember.UserName;
IList <string> userRoles = await memberManager.GetRolesAsync(currentMember);
if (!currentMember.IsApproved)
{
return(PublicAccessStatus.NotApproved);
}
if (currentMember.IsLockedOut)
{
return(PublicAccessStatus.LockedOut);
}
if (!_publicAccessService.HasAccess(publishedContentId, _contentService, username, userRoles))
{
return(PublicAccessStatus.AccessDenied);
}
return(PublicAccessStatus.AccessAccepted);
}
private void button1_Click(object sender, EventArgs e)
{
try
{
Member member = new Member();
IMemberManager imm = ManagerFactory.getMememberManager("MemberMangerImpl");
StringBuilder sb = new StringBuilder();
member.Name = MemberName.Text.Trim();
member.Fatherid = imm.getFatherId(FatherName.Text.Trim());
sb.Append(Year.GetItemText(Year.Items[0]));
sb.Append("/");
sb.Append(Month.GetItemText(Month.Items[0]));
sb.Append("/");
sb.Append(Day.GetItemText(Day.Items[0]));
//MessageBox.Show(sb.ToString());
member.Birth = sb.ToString();
member.BirthPlace = BirthPlace.Text;
member.Generation = Generation.Text.Trim();
member.Idcard = Idcard.Text;
if (Male.Checked)
{
member.Sex = '男';
}
else
{
member.Sex = '女';
}
member.Mapid = imm.getMapid(id);
imm.addMember(member);
}catch (Exception ex)
{
MessageBox.Show(ex.Message);
this.Close();
}
MessageBox.Show("添加成功！");
}
public MemberService(IMemberManager memberManager)
{
_memberManager = memberManager;
}
public MembersController(IMemberManager manager)
{
_manager = manager;
}
public AccountController(IMemberService memberService, IMemberManager memberManager)
{
_memberService = memberService;
_memberManager = memberManager;
}
