public Task <bool> IsValidUser(string provider, string providerKey, string providerAccessCode)
{
using (IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> providerApi = CreateProviderApi(provider))
{
return(providerApi.Object.IsValidUser(providerKey, providerAccessCode));
}
}
/// <summary>
/// Create a new unit of work scope.
/// </summary>
internal UnitOfWorkScope(bool isTransactional, IIocResolver iocResolver)
{
//There is already a uow, do nothing
if (Current != null)
{
return;
}
//this scope started the uow
_isStartedByThisScope = true;
_unitOfWorkWrapper = iocResolver.ResolveAsDisposable <IUnitOfWork>();
try
{
Current = _unitOfWorkWrapper.Object;
Current.Initialize(isTransactional);
Current.Begin();
}
catch
{
Current = null;
throw;
}
}
/// <summary>
/// This method can be used to resolve and release an object automatically.
/// You can use the object in <see cref="doAction" />.
/// </summary>
/// <typeparam name="T">Type of the object to get</typeparam>
/// <param name="iocManager">IIocManager object</param>
/// <param name="doAction"></param>
public static void ResolveUsing <T>(this IIocManager iocManager, Action <T> doAction)
{
using (IDisposableDependencyObjectWrapper <T> wrapper = iocManager.ResolveAsDisposable <T>())
{
doAction(wrapper.Object);
}
}
/// <summary>
/// This method can be used to resolve and release an object automatically.
/// You can use the object in <see cref="func" /> and return a value.
/// </summary>
/// <typeparam name="TService">Type of the service to use</typeparam>
/// <typeparam name="TReturn">Return type</typeparam>
/// <param name="iocManager">IIocManager object</param>
/// <param name="func">A function that can use the resolved object</param>
/// <returns></returns>
public static TReturn ResolveUsing <TService, TReturn>(this IIocManager iocManager, Func <TService, TReturn> func)
{
using (IDisposableDependencyObjectWrapper <TService> wrapper = iocManager.ResolveAsDisposable <TService>())
{
return(func(wrapper.Object));
}
}
/// <summary>
/// 订单支付成功
/// </summary>
/// <param name="productManagerDisposable"></param>
/// <param name="userDownloadConfigManagerDisposable"></param>
/// <param name="userManagerDisposable"></param>
/// <param name="order"></param>
/// <returns></returns>
private async Task SuccessPay(
IDisposableDependencyObjectWrapper <IProductManager> productManagerDisposable,
IDisposableDependencyObjectWrapper <IUserDownloadConfigManager> userDownloadConfigManagerDisposable,
IDisposableDependencyObjectWrapper <AbpUserManager <Role, User> > userManagerDisposable,
Order order
)
{
// 获取产品
var product = await productManagerDisposable.Object.GetProductByCode(order.ProductCode);
// 获取用户
var user = await userManagerDisposable.Object.Users.Where(o => o.Id == order.CreatorUserId)
.AsNoTracking()
.FirstOrDefaultAsync();
// 设置用户下载配置
await userDownloadConfigManagerDisposable.Object.SetUserDownloadConfig(
user,
product.Type,
order.ProductCode,
order.ProductCreateProjectCount,
order.ProductIndate);
// 修改订单状态
order.Status = OrderStatusEnum.ChangeHands;
await _orderManager.Update(order);
}
/// <summary>
/// Create a new unit of work scope.
/// </summary>
public UnitOfWorkScope(bool isTransactional)
{
//There is already a uow, do nothing
if (Current != null)
{
return;
}
//this scope started the uow
_isStartedByThisScope = true;
_unitOfWorkWrapper = IocHelper.ResolveAsDisposable<IUnitOfWork>();
Current = _unitOfWorkWrapper.Object;
try
{
Current.Initialize(isTransactional);
Current.Begin();
}
catch
{
Current = null;
_unitOfWorkWrapper.Dispose();
throw;
}
}
public Task <ExternalAuthUserInfo> GetUserInfo(string provider, string accessCode)
{
using (IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> providerApi = CreateProviderApi(provider))
{
return(providerApi.Object.GetUserInfo(accessCode));
}
}
public void ResolveAsDisposable_With_Constructor_Args_Should_Work()
{
Building(builder => { builder.RegisterServices(f => f.RegisterType <SimpleDisposableObject>()); });
using (IDisposableDependencyObjectWrapper <SimpleDisposableObject> wrapper = LocalIocManager.ResolveAsDisposable <SimpleDisposableObject>(new { myData = 42 }))
{
wrapper.Object.MyData.ShouldBe(42);
}
}
public Task <bool> IsValidUser(string provider, string providerKey, string providerAccessCode)
{
Task <bool> result;
using (IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> disposableDependencyObjectWrapper = this.CreateProviderApi(provider))
{
result = disposableDependencyObjectWrapper.Object.IsValidUser(providerKey, providerAccessCode);
}
return(result);
}
public Task <ExternalAuthUserInfo> GetUserInfo(string provider, string accessCode)
{
Task <ExternalAuthUserInfo> userInfo;
using (IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> disposableDependencyObjectWrapper = this.CreateProviderApi(provider))
{
userInfo = disposableDependencyObjectWrapper.Object.GetUserInfo(accessCode);
}
return(userInfo);
}
private Task <Release> GetReleaseFromCache(IDisposableDependencyObjectWrapper <GitHubClient> gitHubClient)
{
return(_cacheManager.GetCache(CacheNames.ReleaseCache)
.GetAsync(CacheNames.ReleaseCache,
async() => await gitHubClient.Object
.Repository
.Release
.GetLatest(
_configurations.ApplicationConfiguration.GitHubRepositoryOwnerName,
_configurations.ApplicationConfiguration.GitHubRepositoryName)));
}
private DbContext GetDbContext(ActiveTransactionProviderArgs args)
{
Type dbContextProviderType = typeof(IDbContextProvider <>).MakeGenericType((Type)args["ContextType"]);
using (IDisposableDependencyObjectWrapper dbContextProviderWrapper = _iocResolver.ResolveAsDisposable(dbContextProviderType))
{
MethodInfo method = dbContextProviderWrapper.Object.GetType()
.GetMethod("GetDbContext");
return((DbContext)method.Invoke(dbContextProviderWrapper.Object, new object[0]));
}
}
public void IocManager_ShouldResolveDisposableDependency_And_Dispose_After_Scope_Finished()
{
Building(builder => { builder.RegisterServices(f => f.RegisterType <SimpleDisposableDependency>(Lifetime.LifetimeScope)); });
SimpleDisposableDependency simpleDisposableDependency;
using (IDisposableDependencyObjectWrapper <SimpleDisposableDependency> simpleDependencyWrapper = LocalIocManager.ResolveAsDisposable <SimpleDisposableDependency>())
{
simpleDisposableDependency = simpleDependencyWrapper.Object;
}
simpleDisposableDependency.DisposeCount.ShouldBe(1);
}
/// <summary>
/// Create a new unit of work scope.
/// </summary>
public UnitOfWorkScope()
{
_unitOfWorkWrapper = IocHelper.ResolveAsDisposable <IUnitOfWork>();
CurrentUow = _unitOfWorkWrapper.Object;
try
{
CurrentUow.BeginTransaction();
}
catch
{
CurrentUow = null;
}
}
public IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> CreateProviderApi(string provider)
{
ExternalLoginProviderInfo externalLoginProviderInfo = this._externalAuthConfiguration.Providers.FirstOrDefault((ExternalLoginProviderInfo p) => p.Name == provider);
if (externalLoginProviderInfo == null)
{
throw new Exception("Unknown external auth provider: " + provider);
}
IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> disposableDependencyObjectWrapper = IocResolverExtensions.ResolveAsDisposable <IExternalAuthProviderApi>(this._iocResolver, externalLoginProviderInfo.ProviderApiType);
disposableDependencyObjectWrapper.Object.Initialize(externalLoginProviderInfo);
return(disposableDependencyObjectWrapper);
}
/// <summary>
/// Create a new unit of work scope.
/// </summary>
public UnitOfWorkScope()
{
_unitOfWorkWrapper = IocHelper.ResolveAsDisposable<IUnitOfWork>();
CurrentUow = _unitOfWorkWrapper.Object;
try
{
CurrentUow.BeginTransaction();
}
catch
{
CurrentUow = null;
}
}
/// <summary>
/// Create a new unit of work scope.
/// </summary>
public UnitOfWorkScope(bool isTransactional)
{
_unitOfWorkWrapper = IocHelper.ResolveAsDisposable<IUnitOfWork>();
Current = _unitOfWorkWrapper.Object;
try
{
Current.Begin(isTransactional);
}
catch
{
Current = null;
}
}
public IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> CreateProviderApi(string provider)
{
ExternalLoginProviderInfo providerInfo = _externalAuthConfiguration.Providers.FirstOrDefault(p => p.Name == provider);
if (providerInfo == null)
{
throw new Exception("Unknown external auth provider: " + provider);
}
IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> providerApi = _iocResolver.ResolveAsDisposable <IExternalAuthProviderApi>(providerInfo.ProviderApiType);
providerApi.Object.Initialize(providerInfo);
return(providerApi);
}
private static void WithDbContext <TDbContext>(IIocResolver iocResolver, Action <TDbContext> contextAction)
where TDbContext : DbContext
{
using (IDisposableDependencyObjectWrapper <IUnitOfWorkManager> uowManager = iocResolver.ResolveAsDisposable <IUnitOfWorkManager>())
{
using (IUnitOfWorkCompleteHandle uow = uowManager.Object.Begin(TransactionScopeOption.Suppress))
{
TDbContext context = uowManager.Object.Current.GetDbContext <TDbContext>(MultiTenancySides.Host);
contextAction(context);
uow.Complete();
}
}
}
public static void CreateOrConsolidate(this IClientConfiguration clientConfiguration, Action <IClientConfiguration> creator)
{
using (IDisposableDependencyObjectWrapper <IAppConfigManager> appConfigManager = IocManager.Instance.ResolveAsDisposable <IAppConfigManager>())
{
using (
IDisposableDependencyObjectWrapper <IApplicationConfiguration> appConfiguration =
IocManager.Instance.ResolveAsDisposable <IApplicationConfiguration>())
{
creator(clientConfiguration);
appConfiguration.Object.ClientConfiguration = clientConfiguration;
appConfigManager.Object.SaveOrUpdate("ClientId", clientConfiguration.Id);
}
}
}
private DbContext GetDbContext(ActiveTransactionProviderArgs args)
{
Type dbContextProviderType = typeof(IDbContextProvider <>).MakeGenericType((Type)args["ContextType"]);
using (IDisposableDependencyObjectWrapper dbContextProviderWrapper = _iocResolver.ResolveAsDisposable(dbContextProviderType))
{
MethodInfo method = dbContextProviderWrapper.Object.GetType()
.GetMethod(
nameof(IDbContextProvider <CodeZeroDbContext> .GetDbContext),
new[] { typeof(MultiTenancySides) }
);
return((DbContext)method.Invoke(
dbContextProviderWrapper.Object,
new object[] { (MultiTenancySides?)args["MultiTenancySide"] }
));
}
}
private async Task <DbContext> GetDbContextAsync(ActiveTransactionProviderArgs args)
{
var dbContextProviderType = typeof(IDbContextProvider <>).MakeGenericType((Type)args["ContextType"]);
using (IDisposableDependencyObjectWrapper dbContextProviderWrapper =
_iocResolver.ResolveAsDisposable(dbContextProviderType))
{
var method = dbContextProviderWrapper.Object.GetType()
.GetMethod(
nameof(IDbContextProvider <AbpDbContext> .GetDbContextAsync),
new[] { typeof(MultiTenancySides) }
);
var result = await ReflectionHelper.InvokeAsync(method, dbContextProviderWrapper.Object,
new object[] { (MultiTenancySides?)args["MultiTenancySide"] });
return(result as DbContext);
}
}
private void RegisterGenericRepositories()
{
base.IocManager.Register <ExtendedRepositoryRegistrar>();
ITypeFinder tFinder = this._typeFinder;
Type[] dbContextTypes = tFinder.Find(ExtendedDbContextHelper.DoesDBNeedRegisterGenericRepositories);
if (dbContextTypes.IsNullOrEmpty <Type>())
{
this.Logger.Warn("No class found derived from ExtendedDbContextBase.");
return;
}
using (IDisposableDependencyObjectWrapper <ExtendedRepositoryRegistrar> repositoryRegistrar = base.IocManager.ResolveAsDisposable <ExtendedRepositoryRegistrar>())
{
Type[] array = dbContextTypes;
for (int i = 0; i < array.Length; i++)
{
Type dbContextType = array[i];
repositoryRegistrar.Object.RegisterForDbContext(dbContextType, base.IocManager);
}
}
}
public static void Main(string[] args)
{
ParseArgs(args);
using (AbpBootstrapper bootstrapper = AbpBootstrapper.Create <WebShopMigratorModule>())
{
bootstrapper.IocManager.IocContainer
.AddFacility <LoggingFacility>(
f => f.UseAbpLog4Net().WithConfig("log4net.config")
);
bootstrapper.Initialize();
using (IDisposableDependencyObjectWrapper <MultiTenantMigrateExecuter> migrateExecuter = bootstrapper.IocManager.ResolveAsDisposable <MultiTenantMigrateExecuter>())
{
bool migrationSucceeded = migrateExecuter.Object.Run(_quietMode);
if (_quietMode)
{
// exit clean (with exit code 0) if migration is a success, otherwise exit with code 1
int exitCode = Convert.ToInt32(!migrationSucceeded);
Environment.Exit(exitCode);
}
else
{
Console.WriteLine("Press ENTER to exit...");
Console.ReadLine();
}
}
}
}
private void RegisterDapperGenericRepositories()
{
Type[] dbContextTypes =
_typeFinder.Find(type =>
type.IsPublic &&
!type.IsAbstract &&
type.IsClass &&
typeof(AbpDbContext).IsAssignableFrom(type)
);
using (IDisposableDependencyObjectWrapper <IDapperGenericRepositoryRegistrar> repositoryRegistrar = IocManager.ResolveAsDisposable <IDapperGenericRepositoryRegistrar>())
{
foreach (Type dbContextType in dbContextTypes)
{
Logger.Debug("Registering DbContext: " + dbContextType.AssemblyQualifiedName);
repositoryRegistrar.Object.RegisterForDbContext(dbContextType, IocManager);
}
}
}
