public void InjectionParameterReturnsExpectedValue()
{
int expected = 12;
InjectionParameter parameter = new InjectionParameter(expected);
AssertExpectedValue(parameter, typeof(int), expected);
}
public void InjectionParameterCanTakeExplicitType()
{
double expected = Math.E;
InjectionParameter parameter = new InjectionParameter <double>(expected);
AssertExpectedValue(parameter, typeof(double), expected);
}
public void InjectionParameterCanReturnNull()
{
string expected = null;
InjectionParameter parameter = new InjectionParameter(typeof(string), expected);
AssertExpectedValue(parameter, typeof(string), expected);
}
private void AssertExpectedValue(InjectionParameter parameter, Type expectedType, object expectedValue)
{
IResolverPolicy resolver = parameter.GetResolverPolicy(expectedType);
object result = resolver.Resolve(null);
Assert.AreEqual(expectedType, parameter.ParameterType);
AssertExtensions.IsInstanceOfType(resolver, typeof(LiteralValueDependencyResolverPolicy));
Assert.AreEqual(expectedValue, result);
}
public void ObjectsConverterToInjectionParametersResolveCorrectly()
{
List <InjectionParameterValue> values = GetParameterValues(15);
InjectionParameter parameter = (InjectionParameter)values[0];
Assert.AreEqual(typeof(int), parameter.ParameterType);
IResolverPolicy policy = parameter.GetResolverPolicy(null);
int result = (int)policy.Resolve(null);
Assert.AreEqual(15, result);
}
public virtual void Injected_ByResolver_FromEmpty(string test, Type type, string name, Type dependency, object expected)
{
Type target = type.IsGenericTypeDefinition
? type.MakeGenericType(dependency)
: type;
// Arrange
var resolver = new ValidatingResolver(expected);
var parameter = new InjectionParameter(dependency, resolver);
Container.RegisterType(target, name, GetInjectionValue(parameter));
// Act
var instance = Container.Resolve(target, name) as PatternBase;
// Validate
Assert.IsNotNull(instance);
Assert.AreEqual(expected, instance.Value);
}
public OAuth2User GetUser(string identifier, string password)
{
OAuth2User entity = null;
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2UserRepository repository = DependencyInjection.Get<IOAuth2UserRepository>(InjectionParameter.Create("context", context)))
{
OAuth2Scope scope = null;
QueryOver<OAuth2UserScope, OAuth2UserScope> subQuery =
QueryOver.Of<OAuth2UserScope>()
.Where(x => x.ValidFrom <= DateTime.UtcNow)
.And(x => x.ValidUntil > DateTime.UtcNow)
// Join with OAUTH2SCOPE, search for valid data.
.JoinAlias(x => x.Scope, () => scope)
.And(() => scope.ValidFrom <= DateTime.UtcNow)
.And(() => scope.ValidUntil > DateTime.UtcNow)
// Just keep the USER.ID to use in the query.
.Select(t => t.User.ID);
IQueryOver<OAuth2User, OAuth2User> query =
repository.Query()
.Fetch(x => x.UserScopes).Eager
.Fetch(x => x.UserIdentities).Eager
.Where(x => x.Identifier == identifier)
.And(x => x.Password == password)
.WithSubquery.WhereProperty(x => x.ID).In(subQuery)
.TransformUsing(Transformers.DistinctRootEntity);
entity = query.List().SingleOrDefault();
}
context.Commit();
}
return entity;
}
public void InjectionParameterForNullValueReturnsExpectedValueIfTypeIsSuppliedExplicitly()
{
var parameter = new InjectionParameter(typeof(string), null);
AssertExpectedValue(parameter, typeof(string), null);
}
public IList<OAuth2Scope> GetUserScopes(string identifier)
{
IList<OAuth2Scope> set = null;
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2UserScopeRepository repository = DependencyInjection.Get<IOAuth2UserScopeRepository>(InjectionParameter.Create("context", context)))
{
var subQuery =
QueryOver.Of<OAuth2User>()
.Where(x => x.Identifier == identifier)
// Just keep the USER.ID to use in the query.
.Select(t => t.ID);
var userScopeQuery =
repository.Query()
.WithSubquery.WhereProperty(x => x.User.ID).In(subQuery)
.TransformUsing(Transformers.DistinctRootEntity)
.Future<OAuth2UserScope>();
set = userScopeQuery.Select(x=>x.Scope).ToList();
}
context.Commit();
}
return set;
}
public async Task<JsonResult> Get(string resource, Guid identifier)
{
ServiceResponse response = default(ServiceResponse);
using (Session session = ApplicationModel.Current.CreateSession(new SecurityToken(this.HttpContext.Request.Url.Host, this.HttpContext.User.Identity.Name)))
{
try
{
IRestPortal<DataTransferObject> portal = DependencyInjection.Get<IRestPortal<DataTransferObject>>(InjectionParameter.Create("resource", resource));
DataTransferObject value = portal.Get(identifier);
if (default(DataTransferObject) == value) HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
ResponseStatus status = default(DataTransferObject) != value ? ResponseStatus.OK : ResponseStatus.NO_DATA;
response = new ServiceDataResponse(RestVersion0100Controller.API_VERSION, status, value);
}
catch (Exception ex)
{
response = new ServiceErrorResponse(RestVersion0100Controller.API_VERSION, ResponseStatus.ERROR, new ServiceError(ex));
}
}
return this.Json(response, JsonRequestBehavior.AllowGet);
}
public async Task<JsonResult> GetSet(string resource)
{
ServiceResponse response = default(ServiceResponse);
using (Session session = ApplicationModel.Current.CreateSession(new SecurityToken(this.HttpContext.Request.Url.Host, this.HttpContext.User.Identity.Name)))
{
try
{
IDictionary<string, string> parameters = this.GetParameters();
IRestPortal<DataTransferObject> portal = DependencyInjection.Get<IRestPortal<DataTransferObject>>(InjectionParameter.Create("resource", resource));
IEnumerable<DataTransferObject> set = portal.Get(parameters);
ResponseStatus status = ResponseStatus.OK;
response = new ServiceDataResponse(RestVersion0100Controller.API_VERSION, status, set);
}
catch (Exception ex)
{
response = new ServiceErrorResponse(RestVersion0100Controller.API_VERSION, ResponseStatus.ERROR, new ServiceError(ex));
}
}
return this.Json(response, JsonRequestBehavior.AllowGet);
}
public IEnumerable<KeyValuePair<string, DotNetOpenAuth.Messaging.Bindings.CryptoKey>> GetKeys(string bucket)
{
IEnumerable<KeyValuePair<string, DotNetOpenAuth.Messaging.Bindings.CryptoKey>> keySet;
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2CryptoKeyRepository repository = DependencyInjection.Get<IOAuth2CryptoKeyRepository>(InjectionParameter.Create("context", context)))
{
IQueryOver<Entity.OAuth2CryptoKey, Entity.OAuth2CryptoKey> query =
repository
.Query()
.Where(x => x.Bucket == bucket);
var set = query.List();
keySet = set.Select(x => new KeyValuePair<string, DotNetOpenAuth.Messaging.Bindings.CryptoKey>(x.Handle, new DotNetOpenAuth.Messaging.Bindings.CryptoKey(Encoding.Unicode.GetBytes(x.Secret), new DateTime(x.ExpiresUtc.Ticks, DateTimeKind.Utc)))).ToList();
}
context.Commit();
}
return keySet;
}
/// <summary>
/// Get the <see cref="DemoValue"/> entity with the given identifier.
/// </summary>
/// <param name="filters">The parameters for entity selection.</param>
/// <returns>The set of <see cref="DemoValue"/> entities.</returns>
public IList <DemoValue> GetDemoValues(IDictionary <string, string> filters = null)
{
IList <DemoValue> set = default(IList <DemoValue>);
using (IEntityContext context = DependencyInjection.Get <IEntityContext>())
{
using (IDemoValueRepository repository = DependencyInjection.Get <IDemoValueRepository>(InjectionParameter.Create("context", context)))
{
IQueryOver <DemoValue, DemoValue> query =
repository
.Query();
set = query.List();
// The next line is just for demo purposes.
//set.ForEach(item => item.AddCollectionReference(Corporation.Metadata.SUBSIDUARIES_PROPERTY, item.Subsiduaries.Select(e => e.ID.ToString()).ToList()));
}
context.Commit();
}
return(set);
}
public OAuth2UserIdentity SignUpUser(OAuth2UserIdentity entity)
{
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2UserRepository repository = DependencyInjection.Get<IOAuth2UserRepository>(InjectionParameter.Create("context", context)))
{
IList<OAuth2Scope> scopes =
repository.Context.Query<OAuth2Scope>()
.Where(x => x.Code == "application.role.user.default")
.List();
bool isValidIdentifier = this.IsValidEmail(entity.User.Identifier);
if (isValidIdentifier)
{
OAuth2User user = new OAuth2User();
user.ID = Guid.NewGuid();
user.Identifier = entity.User.Identifier;
user.Password = entity.User.Password;
user.CreationTimestamp = DateTime.UtcNow;
user.ValidFrom = DateTime.UtcNow;
user.ValidUntil = new DateTime(DateTime.Parse("2100-01-01").Ticks, DateTimeKind.Utc);
repository.Context.AddOrUpdate(user);
Identity identity = new Identity();
identity.ID = Guid.NewGuid();
identity.FirstName = entity.Identity.FirstName;
identity.Name = entity.Identity.Name;
identity.Locale = entity.Identity.Locale;
repository.Context.AddOrUpdate(identity);
OAuth2UserScope userScope = new OAuth2UserScope();
userScope.ID = Guid.NewGuid();
userScope.Scope = scopes.Single();
userScope.User = user;
userScope.CreationTimestamp = DateTime.UtcNow;
userScope.ValidFrom = DateTime.UtcNow;
userScope.ValidUntil = new DateTime(DateTime.Parse("2100-01-01").Ticks, DateTimeKind.Utc);
repository.Context.AddOrUpdate(userScope);
OAuth2UserIdentity userIdentity = new OAuth2UserIdentity();
userIdentity.ID = Guid.NewGuid();
userIdentity.User = user;
userIdentity.Identity = identity;
userIdentity.CreationTimestamp = DateTime.UtcNow;
userIdentity.ValidFrom = DateTime.UtcNow;
userIdentity.ValidUntil = new DateTime(DateTime.Parse("2100-01-01").Ticks, DateTimeKind.Utc);
repository.Context.AddOrUpdate(userIdentity);
}
else
{
throw new Exception("Invalid e-mail address.");
}
}
context.Commit();
}
Domain.Entity.OAuth2UserIdentity _entity = this.GetUserIdentity(entity.User.Identifier);
return _entity;
}
public void InjectionParameterCanReturnNull()
{
string expected = null;
InjectionParameter parameter = new InjectionParameter(typeof(string), expected);
AssertExpectedValue(parameter, typeof(string), expected);
}
private void AssertExpectedValue(InjectionParameter parameter, Type expectedType, object expectedValue)
{
IDependencyResolverPolicy resolver = parameter.GetResolverPolicy(expectedType);
object result = resolver.Resolve(null);
Assert.AreEqual(expectedType, parameter.ParameterType);
Assert.IsInstanceOfType(resolver, typeof(LiteralValueDependencyResolverPolicy));
Assert.AreEqual(expectedValue, result);
}
public IList<OAuth2Scope> GetScopes(OAuth2ScopeType scopeType)
{
IList<OAuth2Scope> set = null;
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2ScopeRepository repository = DependencyInjection.Get<IOAuth2ScopeRepository>(InjectionParameter.Create("context", context)))
{
string scopeCodeBase = string.Empty;
// Set the value of the scope code to be retrieved.
switch (scopeType)
{
case OAuth2ScopeType.Client:
scopeCodeBase = "application.client.role.";
break;
case OAuth2ScopeType.User:
scopeCodeBase = "application.user.role.";
break;
default:
break;
}
var query =
repository.Query()
.Where(x => x.Code.IsInsensitiveLike(scopeCodeBase, MatchMode.Start))
.AndNot(x=>x.Code.IsInsensitiveLike("guest", MatchMode.End));
set = query.List();
}
context.Commit();
}
return set;
}
public void InjectionParameterForNullValueReturnsExpectedValueIfTypeIsSuppliedExplicitly()
{
var parameter = new InjectionParameter(typeof(string), null);
AssertExpectedValue(parameter, typeof(string), null);
}
public void StoreKey(string bucket, string handle, DotNetOpenAuth.Messaging.Bindings.CryptoKey key)
{
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2CryptoKeyRepository repository = DependencyInjection.Get<IOAuth2CryptoKeyRepository>(InjectionParameter.Create("context", context)))
{
Entity.OAuth2CryptoKey _key = new Entity.OAuth2CryptoKey();
_key.ID = Guid.NewGuid();
_key.Bucket = bucket;
_key.Handle = handle;
_key.Secret = Encoding.Unicode.GetString(key.Key);
_key.ExpiresUtc = key.ExpiresUtc;
repository.AddOrUpdate(_key);
}
context.Commit();
}
}
public void RemoveKey(string bucket, string handle)
{
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2CryptoKeyRepository repository = DependencyInjection.Get<IOAuth2CryptoKeyRepository>(InjectionParameter.Create("context", context)))
{
IQueryOver<Entity.OAuth2CryptoKey, Entity.OAuth2CryptoKey> query =
repository
.Query()
.Where(x => x.Bucket == bucket);
Entity.OAuth2CryptoKey _key = query.List().SingleOrDefault();
repository.Delete(_key);
}
context.Commit();
}
}
public DotNetOpenAuth.Messaging.Bindings.CryptoKey GetKey(string bucket, string handle)
{
DotNetOpenAuth.Messaging.Bindings.CryptoKey key = null;
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2CryptoKeyRepository repository = DependencyInjection.Get<IOAuth2CryptoKeyRepository>(InjectionParameter.Create("context", context)))
{
IQueryOver<Entity.OAuth2CryptoKey, Entity.OAuth2CryptoKey> query =
repository
.Query()
.Where(x => x.Bucket == bucket)
.Where(x => x.Handle == handle);
Entity.OAuth2CryptoKey _key = query.List().SingleOrDefault();
if (_key != null)
{
key = new DotNetOpenAuth.Messaging.Bindings.CryptoKey(Encoding.Unicode.GetBytes(_key.Secret), new DateTime(_key.ExpiresUtc.Ticks, DateTimeKind.Utc));
}
}
context.Commit();
}
return key;
}
/// <summary>
/// Get the <see cref="DemoValue"/> entity with the given identifier.
/// </summary>
/// <param name="identifier">The <see cref="DemoValue"/> identifier.</param>
/// <param name="filters">The parameters for entity selection.</param>
/// <returns>The <see cref="DemoValue"/> entitie with the given identifier.</returns>
public DemoValue GetDemoValue(Guid identifier, IDictionary <string, string> filters = null)
{
DemoValue entity = default(DemoValue);
using (IEntityContext context = DependencyInjection.Get <IEntityContext>())
{
using (IDemoValueRepository repository = DependencyInjection.Get <IDemoValueRepository>(InjectionParameter.Create("context", context)))
{
IQueryOver <DemoValue, DemoValue> query =
repository
.Query()
.Where(x => x.ID == identifier);
entity = query.List().SingleOrDefault();
// The next line is just for demo purposes.
//set.ForEach(item => item.AddCollectionReference(Corporation.Metadata.SUBSIDUARIES_PROPERTY, item.Subsiduaries.Select(e => e.ID.ToString()).ToList()));
}
context.Commit();
}
return(entity);
}
public void InjectionParameterReturnsExpectedValue()
{
int expected = 12;
InjectionParameter parameter = new InjectionParameter(expected);
AssertExpectedValue(parameter, typeof(int), expected);
}
public OAuth2UserIdentity GetUserIdentity(IEntityContext context, string identifier)
{
OAuth2UserIdentity entity = null;
using (IOAuth2UserIdentityRepository repository = DependencyInjection.Get<IOAuth2UserIdentityRepository>(InjectionParameter.Create("context", context)))
{
var subQuery =
QueryOver.Of<OAuth2User>()
.Where(x => x.Identifier == identifier)
// Just keep the USER.ID to use in the query.
.Select(t => t.ID);
var userIdentityQuery =
repository.Query()
.Fetch(x => x.User.UserScopes).Eager
.WithSubquery.WhereProperty(x => x.User.ID).In(subQuery)
.TransformUsing(Transformers.DistinctRootEntity)
.Future<OAuth2UserIdentity>();
OAuth2UserIdentity userIdentity = userIdentityQuery.SingleOrDefault();
if (userIdentity != null) entity = userIdentity;
}
return entity;
}
public void InjectionParameterCanTakeExplicitType()
{
double expected = Math.E;
InjectionParameter parameter = new InjectionParameter<double>(expected);
AssertExpectedValue(parameter, typeof(double), expected);
}
public OAuth2ClientApplication GetClientApplication(string identifier)
{
OAuth2ClientApplication entity = null;
using (IEntityContext context = DependencyInjection.Get<IEntityContext>())
{
using (IOAuth2ClientApplicationRepository repository = DependencyInjection.Get<IOAuth2ClientApplicationRepository>(InjectionParameter.Create("context", context)))
{
IQueryOver<OAuth2ClientApplication, OAuth2ClientApplication> query =
repository
.Query()
.Where(x => x.Identifier == identifier);
entity = query.List().SingleOrDefault();
}
context.Commit();
}
return entity;
}
