コード例 #1
0
ファイル: TenantResolver.cs プロジェクト: zhyzhy782/BodeAbp
        private int?GetTenantIdFromContributors()
        {
            foreach (var resolverType in _multiTenancy.Resolvers)
            {
                using (var resolver = _iocResolver.ResolveAsDisposable <ITenantResolveContributer>(resolverType))
                {
                    var tenantId = resolver.Object.ResolveTenantId();
                    if (tenantId == null)
                    {
                        continue;
                    }

                    if (_tenantStore.Find(tenantId.Value) == null)
                    {
                        continue;
                    }

                    return(tenantId);
                }
            }

            return(null);
        }
コード例 #2
0
ファイル: SeedHelper.cs プロジェクト: lwsadmin/UnionMall
        private static void WithDbContext <TDbContext>(IIocResolver iocResolver, Action <TDbContext> contextAction)
            where TDbContext : DbContext
        {
            //把新增的权限块设置给数据库
            using (var uowManager = iocResolver.ResolveAsDisposable <IUnitOfWorkManager>())
            {
                using (var uow = uowManager.Object.Begin(TransactionScopeOption.Suppress))
                {
                    try
                    {
                        var context = uowManager.Object.Current.GetDbContext <TDbContext>(MultiTenancySides.Host);

                        contextAction(context);

                        uow.Complete();
                    }
                    catch (Exception e)
                    {
                        throw e;
                    }
                }
            }
        }
コード例 #3
0
        protected virtual DbContextOptions <TDbContext> CreateOptions <TDbContext>([NotNull] string connectionString, [CanBeNull] DbConnection existingConnection) where TDbContext : DbContext
        {
            if (_iocResolver.IsRegistered <IAbpDbContextConfigurer <TDbContext> >())
            {
                var configuration = new AbpDbContextConfiguration <TDbContext>(connectionString, existingConnection);

                configuration.DbContextOptions.ReplaceService <IEntityMaterializerSource, AbpEntityMaterializerSource>();

                using (var configurer = _iocResolver.ResolveAsDisposable <IAbpDbContextConfigurer <TDbContext> >())
                {
                    configurer.Object.Configure(configuration);
                }

                return(configuration.DbContextOptions.Options);
            }

            if (_iocResolver.IsRegistered <DbContextOptions <TDbContext> >())
            {
                return(_iocResolver.Resolve <DbContextOptions <TDbContext> >());
            }

            throw new AbpException($"Could not resolve DbContextOptions for {typeof(TDbContext).AssemblyQualifiedName}.");
        }
コード例 #4
0
        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
        {
            //当前方法或者控制器都没有定义校验特性,直接执行方法。
            if (!_configuration.IsValidationEnabledForControllers || !context.ActionDescriptor.IsControllerAction())
            {
                await next();

                return;
            }

            //首先给当前方法增加拦截器记录,表示已经经过AbpCrossCuttingConcerns.Validation处理了。
            using (AbpCrossCuttingConcerns.Applying(context.Controller, AbpCrossCuttingConcerns.Validation))
            {
                using (var validator = _iocResolver.ResolveAsDisposable <MvcActionInvocationValidator>())
                {
                    //然后真正的调用Validate方法
                    validator.Object.Initialize(context);
                    validator.Object.Validate();
                }

                await next();
            }
        }
コード例 #5
0
        /// <summary>
        /// 执行工作
        /// </summary>
        /// <param name="jobInfo"></param>
        private void TryProcessJob(BackgroundJobInfo jobInfo)
        {
            try
            {
                jobInfo.TryCount++;
                jobInfo.LastTryTime = Clock.Now;

                var jobType = Type.GetType(jobInfo.JobType);
                using (var job = _iocResolver.ResolveAsDisposable(jobType))
                {
                    try
                    {
                        var jobExecuteMethod = job.Object.GetType().GetMethod("Execute");
                        var argsType         = jobExecuteMethod.GetParameters()[0].ParameterType;
                        var argsObj          = JsonConvert.DeserializeObject(jobInfo.JobArgs, argsType);

                        jobExecuteMethod.Invoke(job.Object, new[] { argsObj });

                        AsyncHelper.RunSync(() => _store.DeleteAsync(jobInfo));
                    }
                    catch (Exception ex)
                    {
                        Logger.Warn(ex.Message, ex);

                        var nextTryTime = jobInfo.CalculateNextTryTime();
                        if (nextTryTime.HasValue)
                        {
                            jobInfo.NextTryTime = nextTryTime.Value;
                        }
                        else
                        {
                            jobInfo.IsAbandoned = true;
                        }

                        TryUpdate(jobInfo);

                        EventBus.Trigger(
                            this,
                            new AbpHandledExceptionData(
                                new BackgroundJobException(
                                    "A background job execution is failed. See inner exception for details. See BackgroundJob property to get information on the background job.",
                                    ex
                                    )
                        {
                            BackgroundJob = jobInfo,
                            JobObject     = job.Object
                        }
                                )
                            );
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Warn(ex.ToString(), ex);

                jobInfo.IsAbandoned = true;

                TryUpdate(jobInfo);
            }
        }
コード例 #6
0
        public virtual async Task PublishAsync(
            string notificationName,
            NotificationData data             = null,
            EntityIdentifier entityIdentifier = null,
            NotificationSeverity severity     = NotificationSeverity.Info,
            UserIdentifier[] userIds          = null,
            UserIdentifier[] excludedUserIds  = null,
            int?[] tenantIds = null)
        {
            if (notificationName.IsNullOrEmpty())
            {
                throw new ArgumentException("NotificationName can not be null or whitespace!", nameof(notificationName));
            }

            if (!tenantIds.IsNullOrEmpty() && !userIds.IsNullOrEmpty())
            {
                throw new ArgumentException("tenantIds can be set only if userIds is not set!", nameof(tenantIds));
            }

            if (tenantIds.IsNullOrEmpty() && userIds.IsNullOrEmpty())
            {
                tenantIds = new[] { AbpSession.TenantId };
            }

            var notificationInfo = new NotificationInfo(_guidGenerator.Create())
            {
                NotificationName = notificationName,
                EntityTypeName   = entityIdentifier?.Type.FullName,
                EntityTypeAssemblyQualifiedName = entityIdentifier?.Type.AssemblyQualifiedName,
                EntityId        = entityIdentifier?.Id.ToJsonString(),
                Severity        = severity,
                UserIds         = userIds.IsNullOrEmpty() ? null : userIds.Select(uid => uid.ToUserIdentifierString()).JoinAsString(","),
                ExcludedUserIds = excludedUserIds.IsNullOrEmpty() ? null : excludedUserIds.Select(uid => uid.ToUserIdentifierString()).JoinAsString(","),
                TenantIds       = GetTenantIdsAsStr(tenantIds),
                Data            = data?.ToJsonString(),
                DataTypeName    = data?.GetType().AssemblyQualifiedName
            };

            await _store.InsertNotificationAsync(notificationInfo);

            await CurrentUnitOfWork.SaveChangesAsync(); //To get Id of the notification

            if (userIds != null && userIds.Length <= MaxUserCountToDirectlyDistributeANotification)
            {
                //We can directly distribute the notification since there are not much receivers
                foreach (var notificationDistributorType in _notificationConfiguration.Distributers)
                {
                    using (var notificationDistributer = _iocResolver.ResolveAsDisposable <INotificationDistributer>(notificationDistributorType))
                    {
                        await notificationDistributer.Object.DistributeAsync(notificationInfo.Id);
                    }
                }
            }
            else
            {
                //We enqueue a background job since distributing may get a long time
                await _backgroundJobManager.EnqueueAsync <NotificationDistributionJob, NotificationDistributionJobArgs>(
                    new NotificationDistributionJobArgs(
                        notificationInfo.Id
                        )
                    );
            }
        }
コード例 #7
0
        private async Task TryProcessJobAsync(BackgroundJobInfo jobInfo)
        {
            try
            {
                jobInfo.TryCount++;
                jobInfo.LastTryTime = Clock.Now;

                var jobType = Type.GetType(jobInfo.JobType);
                using (var job = _iocResolver.ResolveAsDisposable(jobType))
                {
                    try
                    {
                        var jobExecuteMethod = job.Object.GetType().GetTypeInfo()
                                               .GetMethod(nameof(IBackgroundJob <object> .Execute)) ??
                                               job.Object.GetType().GetTypeInfo()
                                               .GetMethod(nameof(IAsyncBackgroundJob <object> .ExecuteAsync));

                        if (jobExecuteMethod == null)
                        {
                            throw new AbpException(
                                      $"Given job type does not implement {typeof(IBackgroundJob<>).Name} or {typeof(IAsyncBackgroundJob<>).Name}. " +
                                      "The job type was: " + job.Object.GetType());
                        }

                        var argsType = jobExecuteMethod.GetParameters()[0].ParameterType;
                        var argsObj  = JsonConvert.DeserializeObject(jobInfo.JobArgs, argsType);

                        if (jobExecuteMethod.Name == nameof(IAsyncBackgroundJob <object> .ExecuteAsync))
                        {
                            await((Task)jobExecuteMethod.Invoke(job.Object, new[] { argsObj }));
                        }
                        else
                        {
                            jobExecuteMethod.Invoke(job.Object, new[] { argsObj });
                        }

                        await _store.DeleteAsync(jobInfo);
                    }
                    catch (Exception ex)
                    {
                        Logger.Warn(ex.Message, ex);

                        var nextTryTime = jobInfo.CalculateNextTryTime();
                        if (nextTryTime.HasValue)
                        {
                            jobInfo.NextTryTime = nextTryTime.Value;
                        }
                        else
                        {
                            jobInfo.IsAbandoned = true;
                        }

                        await TryUpdateAsync(jobInfo);

                        await EventBus.TriggerAsync(
                            this,
                            new AbpHandledExceptionData(
                                new BackgroundJobException(
                                    "A background job execution is failed. See inner exception for details. See BackgroundJob property to get information on the background job.",
                                    ex
                                    )
                        {
                            BackgroundJob = jobInfo,
                            JobObject = job.Object
                        }
                                )
                            );
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Warn(ex.ToString(), ex);

                jobInfo.IsAbandoned = true;

                await TryUpdateAsync(jobInfo);
            }
        }
コード例 #8
0
        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);
        }
コード例 #9
0
        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();
                }
            }
        }