public async Task <ActionResult <IEnumerable <Person> > > GetPeople(string searchString)
{
//MetaUser user = await _userManager.GetUserAsync(User);
MetaUser user = await _userManager.FindByIdAsync(searchString);
return(await _context.People
.Include(p => p.Addresses)
.Include(p => p.Phones)
.Where(p => p.OwnerId == searchString).ToListAsync());
}
static M()
{
// Interfaces
Object = MetaObject.Instance;
Cachable = MetaCachable.Instance;
Deletable = MetaDeletable.Instance;
Enumeration = MetaEnumeration.Instance;
UniquelyIdentifiable = MetaUniquelyIdentifiable.Instance;
Version = MetaVersion.Instance;
Versioned = MetaVersioned.Instance;
Printable = MetaPrintable.Instance;
Localised = MetaLocalised.Instance;
AccessControlledObject = MetaAccessControlledObject.Instance;
DelegatedAccessControlledObject = MetaDelegatedAccessControlledObject.Instance;
SecurityTokenOwner = MetaSecurityTokenOwner.Instance;
ObjectState = MetaObjectState.Instance;
Task = MetaTask.Instance;
Transitional = MetaTransitional.Instance;
TransitionalVersion = MetaTransitionalVersion.Instance;
User = MetaUser.Instance;
WorkItem = MetaWorkItem.Instance;
// Classes
Employment = MetaEmployment.Instance;
Organisation = MetaOrganisation.Instance;
Person = MetaPerson.Instance;
Settings = MetaSettings.Instance;
Singleton = MetaSingleton.Instance;
Counter = MetaCounter.Instance;
Media = MetaMedia.Instance;
MediaContent = MetaMediaContent.Instance;
PrintDocument = MetaPrintDocument.Instance;
Template = MetaTemplate.Instance;
TemplateType = MetaTemplateType.Instance;
PreparedExtent = MetaPreparedExtent.Instance;
PreparedFetch = MetaPreparedFetch.Instance;
Country = MetaCountry.Instance;
Currency = MetaCurrency.Instance;
Language = MetaLanguage.Instance;
Locale = MetaLocale.Instance;
LocalisedText = MetaLocalisedText.Instance;
AccessControl = MetaAccessControl.Instance;
Login = MetaLogin.Instance;
Permission = MetaPermission.Instance;
Role = MetaRole.Instance;
SecurityToken = MetaSecurityToken.Instance;
AutomatedAgent = MetaAutomatedAgent.Instance;
EmailMessage = MetaEmailMessage.Instance;
Notification = MetaNotification.Instance;
NotificationList = MetaNotificationList.Instance;
TaskAssignment = MetaTaskAssignment.Instance;
TaskList = MetaTaskList.Instance;
UserGroup = MetaUserGroup.Instance;
}
public async Task GetProfileDataAsync(ProfileDataRequestContext context)
{
MetaUser user = await _userManager.GetUserAsync(context.Subject);
List <Claim> claims = new List <Claim>
{
new Claim("FirstName", user.FirstName),
new Claim("LastName", user.LastName),
};
context.IssuedClaims.AddRange(claims);
}
public async Task <IActionResult> PutPerson(
int slug,
[FromForm] bool addressCheck,
[FromForm] bool phoneCheck,
[FromForm] string substring,
[FromForm] Person person,
[FromForm] Address address,
[FromForm] Phone phone)
{
if (person == null)
{
throw new ArgumentNullException(nameof(person));
}
MetaUser user = await _userManager.FindByIdAsync(substring);
if (user is null || slug != person.Id)
{
return(BadRequest());
}
if (addressCheck)
{
_context.Entry(address).State = EntityState.Modified;
person.Addresses.Add(address);
}
if (phoneCheck)
{
_context.Entry(phone).State = EntityState.Modified;
person.Phones.Add(phone);
}
_context.Entry(person).State = EntityState.Modified;
person.OwnerId = substring;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PersonExists(slug))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private async Task LoadAsync(MetaUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
MetaUser user = new MetaUser {
UserName = Input.Email,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation($"User ({user.FirstName} {user.LastName}) created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
private async Task LoadAsync(MetaUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
Username = userName;
Input = new InputModel
{
PhoneNumber = phoneNumber
};
FullName = $"{user.FirstName} {user.LastName}";
}
protected override void Initialize(RequestContext context)
{
string clientToken = context.HttpContext.Request.GetClientToken();
var provider = new Provider(DbConvention.GetTenant());
var token = provider.GetToken(clientToken);
string tenant = DbConvention.GetTenant();
if (token != null)
{
bool isValid = AccessTokens.IsValid(token.ClientToken, context.HttpContext.GetClientIpAddress(),
context.HttpContext.GetUserAgent());
if (isValid)
{
AppUsers.SetCurrentLogin(tenant, token.LoginId);
var loginView = AppUsers.GetCurrent(tenant, token.LoginId);
this.MetaUser = new MetaUser
{
Tenant = tenant,
ClientToken = token.ClientToken,
LoginId = token.LoginId,
UserId = token.UserId,
OfficeId = token.OfficeId
};
var identity = new ClaimsIdentity(token.Claims, DefaultAuthenticationTypes.ApplicationCookie,
ClaimTypes.NameIdentifier, ClaimTypes.Role);
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier,
token.LoginId.ToString(CultureInfo.InvariantCulture)));
if (loginView.RoleName != null)
{
identity.AddClaim(new Claim(ClaimTypes.Role, loginView.RoleName));
}
if (loginView.Email != null)
{
identity.AddClaim(new Claim(ClaimTypes.Email, loginView.Email));
}
context.HttpContext.User = new ClaimsPrincipal(identity);
}
}
base.Initialize(context);
}
protected override void Initialize(HttpControllerContext context)
{
string database = DbConvention.GetTenant();
string clientToken = context.Request.GetBearerToken();
var provider = new Provider(database);
var token = provider.GetToken(clientToken);
if (token != null)
{
AppUsers.SetCurrentLogin(database, token.LoginId);
var loginView = AppUsers.GetCurrent(database, token.LoginId);
this.MetaUser = new MetaUser
{
Tenant = database,
ClientToken = token.ClientToken,
LoginId = token.LoginId,
UserId = loginView.UserId.To <int>(),
OfficeId = loginView.OfficeId.To <int>()
};
var identity = new ClaimsIdentity(token.Claims);
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, token.LoginId.ToString(CultureInfo.InvariantCulture)));
if (loginView.RoleName != null)
{
identity.AddClaim(new Claim(ClaimTypes.Role, loginView.RoleName));
}
if (loginView.Email != null)
{
identity.AddClaim(new Claim(ClaimTypes.Email, loginView.Email));
}
context.RequestContext.Principal = new ClaimsPrincipal(identity);
}
base.Initialize(context);
}
public async Task <ActionResult <Person> > PostPerson(
[FromForm] string substring,
[FromForm] bool addressCheck,
[FromForm] bool phoneCheck,
[FromForm] Person peep,
[FromForm] Address address,
[FromForm] Phone phone)
{
MetaUser user = await _userManager.FindByIdAsync(substring);
if (user is null)
{
throw new ArgumentNullException(nameof(user));
}
Person person = peep;
// Check for an address
if (addressCheck)
{
Address addy = address;
person.Addresses.Add(addy);
}
// Check for a phone
if (phoneCheck)
{
Phone caller = phone;
person.Phones.Add(caller);
}
person.OwnerId = substring;
_context.People.Add(person);
user.UserContacts.Add(person);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPerson", new { id = person.Id }, person));
}
public async Task IsActiveAsync(IsActiveContext context)
{
MetaUser user = await _userManager.GetUserAsync(context.Subject);
context.IsActive = (user != null);
}
static bool IsMetaUserStale(MetaUser meta)
{
//clear warnings older than an hour
meta.Warnings.RemoveAll(new Predicate<Warning>(HasWarningExpired));
//tag if elevated or warnings are still out
if (meta.Elevation || meta.JTVModerator || meta.Warnings.Count > 0 || (DateTime.UtcNow - meta.DeopTime).TotalHours < 1.0)
{
return false;
}
//inform referencing users
List<User> copy = new List<User>(meta.References);
foreach (User user in copy)
{
user.Meta = null;
}
//list should be empty
Debug.Assert(meta.References.Count == 0);
//item now stale
return true;
}
