public MethodInvocationContext(MethodInfo method,
ServiceHandlerConfiguration serviceConfiguration,
ServiceHandlerConfigurationInstance instanceConfiguration)
{
InstanceConfiguration = instanceConfiguration;
ServiceConfiguration = serviceConfiguration;
MethodInfo = method;
var attrib = (AsyncStateMachineAttribute)method.GetCustomAttribute(typeof(AsyncStateMachineAttribute));
if (attrib != null)
{
IsAsync = true;
}
RestAttribute = method.GetCustomAttribute(typeof(RestAttribute), true) as RestAttribute;
if (RestAttribute == null)
{
return;
}
// set allowable authorization roles
if (RestAttribute.AuthorizationRoles != null)
{
AuthorizationRoles = RestAttribute.AuthorizationRoles
.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.ToList();
if (AuthorizationRoles.Count == 0)
{
AuthorizationRoles.Add(string.Empty); // Any authorized user
}
}
}
public bool IsInRole(AuthorizationRoles role)
{
string principalRole = this.CurrentRole.ToString();
var roleArray = new string[3];
if (role.HasFlag(AuthorizationRoles.User))
{
roleArray[0] = "User";
}
if (role.HasFlag(AuthorizationRoles.Seller))
{
roleArray[1] = "Seller";
}
if (role.HasFlag(AuthorizationRoles.Admin))
{
roleArray[2] = "Admin";
}
if (roleArray.Any(authRole => string.Compare(principalRole, authRole, StringComparison.InvariantCultureIgnoreCase) == 0))
{
return(true);
}
return(false);
}
public override void LoadFor(DatabaseDocument databaseDocument)
{
var session = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(databaseDocument.Id);
session.Advanced.LoadStartingWithAsync <AuthorizationUser>("Authorization/Users").
ContinueOnSuccessInTheUIThread(data =>
{
AuthorizationUsers.Clear();
foreach (var authorizationUser in data)
{
AuthorizationUsers.Add(authorizationUser);
}
foreach (var authorizationUser in data)
{
OriginalAuthorizationUsers.Add(authorizationUser);
}
});
session.Advanced.LoadStartingWithAsync <AuthorizationRole>("Authorization/Roles").
ContinueOnSuccessInTheUIThread(data =>
{
AuthorizationRoles.Clear();
foreach (var authorizationRole in data)
{
AuthorizationRoles.Add(authorizationRole);
}
foreach (var authorizationRole in data)
{
OriginalAuthorizationRoles.Add(authorizationRole);
}
});
}
public bool IsInRole(string role)
{
AuthorizationRole authorizationRole;
Enum.TryParse(role, true, out authorizationRole);
return(AuthorizationRoles.Contains(authorizationRole));
}
private void HandleDeleteAuthorizationRole(object parameter)
{
var role = parameter as AuthorizationRole;
if (role == null)
{
return;
}
AuthorizationRoles.Remove(role);
SelectedRole = null;
}
public override void LoadFor(DatabaseDocument _)
{
var session = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(ApplicationModel.Current.Server.Value.SelectedDatabase.Value.Name);
session.Advanced.LoadStartingWithAsync <AuthorizationUser>("Authorization/Users").
ContinueOnSuccessInTheUIThread(data =>
{
AuthorizationUsers.Clear();
foreach (var authorizationUser in data)
{
AuthorizationUsers.Add(authorizationUser);
}
foreach (var authorizationUser in data)
{
OriginalAuthorizationUsers.Add(authorizationUser);
}
AuthorizationUsers.CollectionChanged += (sender, args) => HasUnsavedChanges = true;
});
session.Advanced.LoadStartingWithAsync <AuthorizationRole>("Authorization/Roles").
ContinueOnSuccessInTheUIThread(data =>
{
AuthorizationRoles.Clear();
foreach (var authorizationRole in data)
{
AuthorizationRoles.Add(authorizationRole);
}
foreach (var authorizationRole in data)
{
OriginalAuthorizationRoles.Add(authorizationRole);
}
AuthorizationRoles.CollectionChanged += (sender, args) => HasUnsavedChanges = true;
});
}
public Task <IList <object> > ProvideSuggestions(string enteredText)
{
return(ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession().Advanced
.LoadStartingWithAsync <AuthorizationRole>("Authorization/Roles")
.ContinueOnSuccess(roles => (IList <object>)AuthorizationRoles.Select(role => role.Id).Cast <object>().ToList()));
}
public CustomAuthorizationFilter(AuthorizationRoles _authorizationRoles)
{
this._authorizationRoles = _authorizationRoles;
}
public async Task <IHttpActionResult> AddInvite(InviteUser model)
{
if (String.IsNullOrEmpty(model.EmailAddress))
{
throw new ValidationException(new[] { new ValidationFailure("email_address", "Please enter an email address") });
}
var role = model.Role;
if (String.IsNullOrEmpty(role))
{
role = AuthorizationRoles.User;
}
if (!AuthorizationRoles.AllScopes.Contains(role))
{
return(BadRequest());
}
Organization organization = await GetModel(GetSelectedOrganizationId());
if (organization == null)
{
return(BadRequest());
}
var currentUser = CurrentUser;
// need to check for global admin here
var addGlobalAdmin = false;
if (role == AuthorizationRoles.GlobalAdmin)
{
if (currentUser.IsGlobalAdmin())
{
addGlobalAdmin = true;
role = AuthorizationRoles.Admin;
}
else
{
// downgrade to current user's role
role = currentUser.IsAdmin(organization.Id) ? AuthorizationRoles.Admin : AuthorizationRoles.User;
}
}
else if (role == AuthorizationRoles.Admin && !currentUser.IsAdmin(organization.Id))
{
role = AuthorizationRoles.User;
}
var user = await _userRepository.GetByEmailAddressAsync(model.EmailAddress);
// user exists, just add them to the org
if (user != null)
{
if (addGlobalAdmin)
{
// will be false only if user is already a global admin
addGlobalAdmin = user.AddedGlobalAdminRole();
}
if (user.AddedMembershipRole(organization.Id, role) || addGlobalAdmin)
{
await _userRepository.SaveAsync(user);
await _messagePublisher.PublishAsync(new UserMembershipChanged {
ChangeType = ChangeType.Added,
UserId = user.Id,
OrganizationId = organization.Id
}, TimeSpan.FromSeconds(1.5)).AnyContext();
}
_mailer.SendAddedToOrganization(currentUser, organization, user);
return(Ok(new InviteUserResponse {
Added = true, UserId = user.Id, EmailAddress = model.EmailAddress
}));
}
Invite invite = organization.Invites.FirstOrDefault(i => String.Equals(i.EmailAddress, model.EmailAddress, StringComparison.OrdinalIgnoreCase));
if (invite == null)
{
invite = new Invite {
Token = StringUtils.GetNewToken(),
EmailAddress = model.EmailAddress.ToLower(),
FullName = model.FullName,
DateAdded = DateTime.UtcNow,
AddedByUserId = currentUser.Id,
Roles = addGlobalAdmin
? AuthorizationRoles.GetScope(AuthorizationRoles.GlobalAdmin)
: AuthorizationRoles.GetScope(role)
};
organization.Invites.Add(invite);
await _repository.SaveAsync(organization);
}
_mailer.SendInvite(currentUser, organization, invite);
return(Ok(new InviteUserResponse {
Invited = true, EmailAddress = model.EmailAddress
}));
}
