public EnglishMultimediaStatisticRepository(
ICompletedEnglishMultimediaRepository completedEnglishMultimediaRepository,
DomainMapper domainMapper)
{
_completedEnglishMultimediaRepository = completedEnglishMultimediaRepository;
_mapper = domainMapper.Mapper;
}
public void SeedDomain(string seedPath)
{
DomainSeed[] domainArray;
using (var domainStream = new StreamReader(seedPath + "/domain.json"))
{
domainArray = JsonConvert.DeserializeObject <DomainSeed[]>(domainStream.ReadToEnd());
}
foreach (var domainSeed in domainArray)
{
var dbDomain = _domainRepository.GetById(domainSeed.Id);
if (dbDomain == null)
{
var newDomain = DomainMapper.MapSeedToEntity(domainSeed);
newDomain.CreatedBy = "SeedDomain";
newDomain.SeedData = true;
_domainRepository.Add(newDomain);
}
else
{
DomainMapper.MapSeedToEntity(domainSeed, dbDomain);
dbDomain.ModifiedBy = "SeedDomain";
_domainRepository.Update(dbDomain);
}
}
}
protected override bool IsAuthorized(HttpActionContext actionContext)
{
if (actionContext == null)
{
throw new ArgumentNullException("actionContext");
}
IPrincipal user = actionContext.ControllerContext.RequestContext.Principal;
if (user == null || user.Identity == null || !user.Identity.IsAuthenticated)
{
return(false);
}
if (SplitString(Users).Length > 0 && !(SplitString(Users).Contains(user.Identity.Name, StringComparer.OrdinalIgnoreCase)))
{
return(false);
}
// Role preparation
List <string> allowedRolesRaw = new List <string>(SplitString(Roles));
string allowedRolesAd = "";
allowedRolesRaw.ForEach(rc => allowedRolesAd += DomainMapper.GetRolesActiveDirectoryGroupName(DomainMapper.GetRoleIdFromAttributeName(rc), true) + ", ");
if (SplitString(Roles).Length > 0 && !(SplitString(allowedRolesAd).Any(user.IsInRole)))
{
return(false);
}
return(true);
}
public EnglishTaskStatisticRepository(
ICompletedEnglishTaskRepository completedEnglishTaskRepository,
DomainMapper domainMapper)
{
_completedEnglishTaskRepository = completedEnglishTaskRepository;
_mapper = domainMapper.Mapper;
}
private IMapper ConfigureMapper()
{
var mapperConfiguration = new MapperConfiguration(config => {
ApiMapper.Config(config);
DomainMapper.Config(config);
});
return(mapperConfiguration.CreateMapper());
}
public DomainViewModel UpdateDomain(int id, DomainViewModel domain)
{
var domainToUpdate = _domainRepository.GetById(id);
DomainMapper.MapModelToEntity(domain, domainToUpdate);
domainToUpdate.ModifiedBy = "TEST";
var updatedDomain = _domainRepository.Update(domainToUpdate);
return(DomainMapper.MapEntityToModel(updatedDomain));
}
public DomainViewModel AddDomain(DomainViewModel domain)
{
var domainToAdd = DomainMapper.MapModelToEntity(domain);
domainToAdd.CreatedBy = "TEST";
domainToAdd.SeedData = false;
var addedDomain = _domainRepository.Add(domainToAdd);
return(DomainMapper.MapEntityToModel(addedDomain));
}
public override void Build(DomainMapper masterMap, Formatter<PropertyInfo> formatter)
{
base.Build(masterMap, formatter);
var mappedType = masterMap.For(Property.PropertyType.GetGenericArguments()[0]);
if(!mappedType.SubMappings.Any()) throw new Exception(string.Format("No mappings found type {0}", Property.PropertyType.GetGenericArguments()[0]));
var foreignKey = mappedType.SubMappings.OfType<IdMapping>().First().Property;
this.foreignRelationshipMapping = new ReverseForeignRelationshipMapping(Property, type, parentType, foreignKey, formatter);
masterMap.For(type).Map(mapping => mapping.MapForeignRelationship(masterMap, Property, type, formatter));
}
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
//初始化映射关系
DomainMapper.Initialize();
}
public static void Main(string[] args)
{
Console.WriteLine("Collecting updates from weather server…");
var domainMapper = new DomainMapper();
var propertyManager = new PropertyManager();
var repository = new ZmqRepository(domainMapper, propertyManager, @"C:\temp\data");
var cities = repository.GetAll <City>();
foreach (var city in cities)
{
Console.WriteLine(string.Format("Received: {0}, Weather: {1}", city.ToInfo(), city.Weather.ToInfo()));
}
}
public override void Build(DomainMapper masterMap, Formatter <PropertyInfo> formatter)
{
base.Build(masterMap, formatter);
var mappedType = masterMap.For(Property.PropertyType.GetGenericArguments()[0]);
if (!mappedType.SubMappings.Any())
{
throw new Exception(string.Format("No mappings found type {0}", Property.PropertyType.GetGenericArguments()[0]));
}
var foreignKey = mappedType.SubMappings.OfType <IdMapping>().First().Property;
this.foreignRelationshipMapping = new ReverseForeignRelationshipMapping(Property, type, parentType, foreignKey, formatter);
masterMap.For(type).Map(mapping => mapping.MapForeignRelationship(masterMap, Property, type, formatter));
}
public static List <Domain> GetCustomerDomains(PartnerSdkModels.Customers.Customer customer)
{
List <Domain> result = new List <Domain>();
// Initialize the Azure AD Graph API helper with the customer tenant
_azureADGraphApiHelper = new AzureADGraphApiHelper(customer.Id);
// Get request client
HttpWebRequest request = _azureADGraphApiHelper.BuildGetCustomerDomainsRequest();
// Execute request
dynamic requestResult = request.TryCatchRequest();
foreach (dynamic domain in requestResult.value)
{
result.Add(DomainMapper.MapFromJson(customer.Id, domain));
}
return(result);
}
internal static bool IsValidEmail(string strIn)
{
if (string.IsNullOrEmpty(strIn))
{
return(false);
}
// Use IdnMapping class to convert Unicode domain names
var domainMapper = new DomainMapper();
strIn = Regex.Replace(strIn, @"(@)(.+)$", domainMapper.MatchEvaluator);
if (domainMapper.Invalid)
{
return(false);
}
// Return true if strIn is in valid e-mail format
return(Regex.IsMatch(strIn,
@"^(?("")(""[^""]+?""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" +
@"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-\w]*[0-9a-z]*\.)+[a-z0-9]{2,17}))$",
RegexOptions.IgnoreCase));
}
public static void Main(string[] args)
{
IDictionary <int, City> cities = new Dictionary <int, City>();
var domainMapper = new DomainMapper();
var propertyManager = new PropertyManager();
var repository = new ZmqRepository(domainMapper, propertyManager, @"C:\temp\data");
IUnitOfWork unitOfWork = new ChangeTrackUoW(propertyManager, repository);
var randomizer = new Random(DateTime.Now.Millisecond);
var weather = new Weather {
Temperature = randomizer.Next(-80, 135), RelativeHumidity = randomizer.Next(10, 60)
};
for (var i = 0; i < 3; i++)
{
var city = new City
{
CitySize = CitySize.Medium,
Name = "Test",
ZipCode = randomizer.Next(1, 100000),
Weather = weather
};
unitOfWork.StartTransaction(city);
try
{
unitOfWork.Commit();
}
catch (System.Exception exception)
{
unitOfWork.Rollback();
Console.WriteLine("Error: " + exception.Message);
}
}
}
/// <inheritdoc />
public virtual async Task UpdateTransactionAsync(Transaction transaction, CancellationToken cancellationToken = default)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
var record = await Context
.Transactions
.SingleOrDefaultAsync(model => model.Id == transaction.Id, cancellationToken);
if (record == null)
{
throw new InvalidOperationException($"No transaction records found in database with id {transaction.Id}");
}
DomainMapper.MapTransaction(record, transaction);
record.UpdatedOn = DateTime.UtcNow;
Context.Transactions.Update(record);
await Context.SaveChangesAsync(cancellationToken);
}
public void Should_work_with_nhibernate()
{
Configuration configuration = new Configuration();
configuration.SessionFactory()
.Integrate.Using <SQLiteDialect>()
.Connected.Using(new SQLiteConnectionStringBuilder {
DataSource = ":memory:", Version = 3
}).LogSqlInConsole();
configuration.AddDeserializedMapping(DomainMapper.GetMappings(), "domain");
using (var factory = configuration.BuildSessionFactory())
{
using (var session = factory.OpenSession())
{
new SchemaExport(configuration).Execute(true, true, false, session.Connection, Console.Out);
ProductsCalculator productsCalculator = new ProductsCalculator(new Repository <Product>(session));
var price = productsCalculator.GetTotalPrice();
Assert.That(price, Is.EqualTo(0));
}
}
}
/// <inheritdoc />
public virtual async Task UpdatePaymentAsync(Payment payment, CancellationToken cancellationToken = default)
{
if (payment == null)
{
throw new ArgumentNullException(nameof(payment));
}
var record = await Context
.Payments
.AsNoTracking()
.SingleOrDefaultAsync(model => model.Id == payment.Id, cancellationToken);
if (record == null)
{
throw new InvalidOperationException($"No payment records found in database with id {payment.Id}");
}
DomainMapper.MapPayment(record, payment);
record.UpdatedOn = DateTime.UtcNow;
Context.Payments.Update(record);
await Context.SaveChangesAsync(cancellationToken);
}
public OneToManyHandler(Formatter<PropertyInfo> foreignKeyFormatter, DomainMapper masterMap)
{
this.foreignKeyFormatter = foreignKeyFormatter;
this.masterMap = masterMap;
}
private IObservable <Trade> MapToDomainTrade(IObservable <MessageDTO <MessageTrade> > input)
{
// TODO: Add implementation to mapping to com.example.part_10.domain.Trade
return(input.Select(m => DomainMapper.MapToDomain(m)));
}
public EntityHandler(IIdentifier <Type> entityIdentifier, Formatter <PropertyInfo> foreignKeyFormatter, DomainMapper masterMap)
{
this.entityIdentifier = entityIdentifier;
this.foreignKeyFormatter = foreignKeyFormatter;
this.masterMap = masterMap;
}
public DomainViewModel GetDomainById(int id)
{
return(DomainMapper.MapEntityToModel(_domainRepository.GetById(id)));
}
public ClassConvention(DomainMapper masterMap)
{
this.masterMap = masterMap;
this.componentHandler = new ComponentHandler();
}
public OneToManyHandler(Formatter <PropertyInfo> foreignKeyFormatter, DomainMapper masterMap)
{
this.foreignKeyFormatter = foreignKeyFormatter;
this.masterMap = masterMap;
}
public EntityHandler(IIdentifier<Type> entityIdentifier, Formatter<PropertyInfo> foreignKeyFormatter, DomainMapper masterMap)
{
this.entityIdentifier = entityIdentifier;
this.foreignKeyFormatter = foreignKeyFormatter;
this.masterMap = masterMap;
}
public static void Main(string[] args)
{
IServiceCollection services = new ServiceCollection();
var confbuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
IConfigurationRoot Configuration = confbuilder.Build();
services.AddSerializerServices();
services.AddDbContext <JyDbContext>(options => options.UseMySql(Configuration.GetConnectionString("MySql")), ServiceLifetime.Scoped);//mysql
//services.AddDbContext<JyDBReadContext>(options => options.UseMySql(Configuration.GetConnectionString("MySqlRead")), ServiceLifetime.Scoped);//mysqlread
//目前使用2个DbContextPool不好弄
//services.AddDbContextPool<JyDbContext>(
// options => options.UseMySql(Configuration.GetConnectionString("MySql"),
// mysqlOptions => mysqlOptions.MaxBatchSize(100)));
services.AddDbContextPool <JyDBReadContext>(
options => options.UseMySql(Configuration.GetConnectionString("MySqlRead"),
mysqlOptions => mysqlOptions.MaxBatchSize(100)));
services.Configure <SDBSettings>(Configuration.GetSection("SDBSettings"));
services.Configure <SIndexSettings>(Configuration.GetSection("SIndexSettings"));
DomainMapper.Initialize();
//services.AddRawRabbit();
//分布式锁,redis实现
services.AddSingleton <Redlock>(new Redlock(Configuration.GetSection("CacheConfig").GetValue <string>("Redis_ConnectionString")));
services.AddScoped <ProcessMessageLockHandler>();
//txtlog
services.AddSingleton <ILog.ILogger, Logger>();
//依赖注入
services.AddScoped <PagedHelper>();
services.AddScoped <ICacheService, Jy.CacheService.CacheService>();
services.AddScoped <IQueueService, Jy.QueueSerivce.QueueSerivce>();
services.AddScoped <IRepositoryContext, AuthRepositoryContext>();
services.AddScoped <IRepositoryReadContext, AuthRepositoryReadContext>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IUserAppService, UserAppService>();
services.AddScoped <IMenuRepository, MenuRepository>();
services.AddScoped <IMenuAppService, MenuAppService>();
services.AddScoped <IDepartmentRepository, DepartmentRepository>();
services.AddScoped <IDepartmentAppService, DepartmentAppService>();
services.AddScoped <IRoleRepository, RoleRepository>();
services.AddScoped <IRoleAppService, RoleAppService>();
services.AddScoped <IUserRepositoryRead, UserRepositoryRead>();
services.AddScoped <IRoleRepositoryRead, RoleRepositoryRead>();
services.AddScoped <IMenuRepositoryRead, MenuRepositoryRead>();
services.AddScoped <IDepartmentRepositoryRead, DepartmentRepositoryRead>();
services.AddScoped <IRepositoryFactory, RepositoryFactory>();
services.AddScoped <IRepositoryReadFactory, RepositoryReadFactory>();
services.AddScoped(factory => {
Func <string, IRepositoryFactory> accesor = (key) =>
{
if (key.Equals("EF"))
{
return(factory.GetService <RepositoryFactory>());
}
else if (key.Equals("DP"))
{
return(factory.GetService <Jy.Dapper.Repositories.DPRepositoryFactory>());
}
else
{
throw new ArgumentException($"Not Support key :{key}");
}
};
return(accesor);
});
//MQ
//services.AddScoped(typeof(IProcessMessage));
//handlers
services.AddScoped(typeof(ProcessUser_delete_deleteuser_normal));
services.AddScoped(typeof(ProcessUser_delete_deleteuser_normal_2));
services.AddScoped(typeof(ProcessUser_update_insertupdate_rpc));
services.AddScoped(typeof(ProcessUser_update_insertupdate_rpc_2));
services.AddScoped(typeof(ProcessUser_update_userroles_normal));
services.AddScoped(typeof(ProcessRoleRole_delete_deleterole_normal));
services.AddScoped(typeof(ProcessRoleRole_delete_others_normal));
services.AddScoped(typeof(ProcessRoleRole_update_insertupdate_rpc));
services.AddScoped(typeof(ProcessRoleRole_update_others_normal));
services.AddScoped(typeof(ProcessRoleRole_update_rolemenus_normal));
services.AddScoped(typeof(ProcessRoleRole_rolemenus_others_normal));
services.AddScoped(typeof(ProcessMenuMenu_delete_deletemenu_normal));
services.AddScoped(typeof(ProcessMenuMenu_delete_others_normal));
services.AddScoped(typeof(ProcessMenuMenu_update_insertupdate_rpc));
services.AddScoped(typeof(ProcessMenuMenu_update_others_normal));
services.AddScoped(typeof(ProcessDepartmentDepartment_delete_deletedepartment_normal));
services.AddScoped(typeof(ProcessDepartmentDepartment_delete_others_normal));
services.AddScoped(typeof(ProcessDepartmentDepartment_update_insertupdate_rpc));
services.AddScoped(typeof(ProcessDepartmentDepartment_update_others_normal));
services.AddScoped(typeof(ProcessOperateLog));
services.AddScoped <IProcessMessage, ProcessUser_delete_deleteuser_normal>(); //这里需要注册IProcessMessage接口的默认实例，不然异常
//services.AddScoped<IQueueOperation, QueueOperationRawRabbit>();
//services.AddScoped<IQueueOperationSubscriptionsManager, InMemorySubscriptionsManager>();
//RabbitMQ
services.AddRabbitMQServices(Configuration);
services.AddScoped(typeof(ProcessMessageDecorator <>));
//------------------------kafka
//services.AddScoped<IBigQueueOperation, QueueOperationRdKafka>();
services.AddCKafkaServices(Configuration);
//------------------------kafka
IServiceProvider serviceProvider = services.BuildServiceProvider();
//-------------------------------------------------------serilog 配置
ConsLogOptions authLogOptions = new ConsLogOptions()
{
LogPath = "D:\\LogFiles_MQ",//Configuration[nameof(AuthLogOptions.LogPath)],
PathFormat = "MQ_{Date}.log"
};
var serilog = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.RollingFile(Path.Combine(authLogOptions.LogPath, authLogOptions.PathFormat),
outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {Message}{NewLine}{Exception}");
ConsLogOptions.EnsurePreConditions(authLogOptions);
var logger = serilog.CreateLogger();
//---------------------------------------------------serilog 配置
logger.Information("-------------ConsumerAuth start,begin init:");
//IProcessMessage pm = serviceProvider.GetService<IProcessMessage>();
IQueueOperation qo = serviceProvider.GetService <IQueueOperation>();
//JyDbContext cntexta = serviceProvider.GetService<JyDbContext>();
logger.Information("launch ErrorSubscribe");
//errorHandle
qo.ErrorSubscribe();
ProcessMessageLockHandler lockhandler = (ProcessMessageLockHandler)serviceProvider.GetService(typeof(ProcessMessageLockHandler));//分布式锁处理类
SubscribeTopic <user_delete_deleteuser_normal, ProcessUser_delete_deleteuser_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "user_delete_deleteuser_normal", "user_delete_deleteuser_normal");
SubscribeTopic <user_delete_deleteuser_normal, ProcessUser_delete_deleteuser_normal_2>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "user_delete_deleteuser_normal", "user_delete_deleteuser_normal");
ResponseTopic <user_update_insertupdate_rpc, ProcessUser_update_insertupdate_rpc>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "user_update_insertupdate_rpc", "user_update_insertupdate_rpc");
ResponseTopic <user_update_insertupdate_rpc, ProcessUser_update_insertupdate_rpc_2>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "user_update_insertupdate_rpc", "user_update_insertupdate_rpc");
SubscribeTopic <user_update_userroles_normal, ProcessUser_update_userroles_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "user_update_userroles_normal", "user_update_userroles_normal");
SubscribeTopic <role_delete_deleterole_normal, ProcessRoleRole_delete_deleterole_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "role_delete_deleterole_normal", "role_delete_deleterole_normal");
SubscribeTopic <role_delete_others_normal, ProcessRoleRole_delete_others_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "role_delete_others_normal", "role_rolemenus_others_normal");
ResponseTopic <role_update_insertupdate_rpc, ProcessRoleRole_update_insertupdate_rpc>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "role_update_insertupdate_rpc", "role_update_insertupdate_rpc");
SubscribeTopic <role_update_others_normal, ProcessRoleRole_update_others_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "role_update_others_normal", "role_update_others_normal");
SubscribeTopic <role_update_rolemenus_normal, ProcessRoleRole_update_rolemenus_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "role_update_rolemenus_normal", "role_update_rolemenus_normal");
SubscribeTopic <role_rolemenus_others_normal, ProcessRoleRole_rolemenus_others_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "role_rolemenus_others_normal", "role_rolemenus_others_normal");
SubscribeTopic <menu_delete_deletemenu_normal, ProcessMenuMenu_delete_deletemenu_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "menu_delete_deletemenu_normal", "menu_delete_deletemenu_normal");
SubscribeTopic <menu_delete_others_normal, ProcessMenuMenu_delete_others_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "menu_delete_others_normal", "menu_delete_others_normal");
ResponseTopic <menu_update_insertupdate_rpc, ProcessMenuMenu_update_insertupdate_rpc>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "menu_update_insertupdate_rpc", "menu_update_insertupdate_rpc");
ResponseTopic <menu_update_others_normal, ProcessMenuMenu_update_others_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "menu_update_others_normal", "menu_update_others_normal");
SubscribeTopic <department_delete_deletedepartment_normal, ProcessDepartmentDepartment_delete_deletedepartment_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "department_delete_deletedepartment_normal", "department_delete_deletedepartment_normal");
SubscribeTopic <department_delete_others_normal, ProcessDepartmentDepartment_delete_others_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "department_delete_others_normal", "department_delete_others_normal");
ResponseTopic <department_update_insertupdate_rpc, ProcessDepartmentDepartment_update_insertupdate_rpc>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "department_update_insertupdate_rpc", "department_update_insertupdate_rpc");
ResponseTopic <department_update_others_normal, ProcessDepartmentDepartment_update_others_normal>(serviceProvider, lockhandler, logger, qo, "auth.exchange", "department_update_others_normal", "department_update_others_normal");
//kafaka
IBigQueueOperation bqo = serviceProvider.GetService <IBigQueueOperation>();
ProcessOperateLog pol = (ProcessOperateLog)serviceProvider.GetService(typeof(ProcessOperateLog));
ProcessMessageDecorator <MessageBase> pold = new ProcessMessageDecorator <MessageBase>(pol, lockhandler);//分布式锁装饰类
bqo.SubscribeTopic <MessageBase, ProcessMessageDecorator <MessageBase> >(() => { return(pold); }, "", "auth", new List <string> {
"auth.operate"
});
logger.Information("-------------ConsumerAuth start,end init");
#region old init
//ProcessUser User Operation Listener
//ProcessUser_delete_deleteuser_normal pddn = serviceProvider.GetRequiredService<ProcessUser_delete_deleteuser_normal>();
//ProcessMessageDecorator<user_delete_deleteuser_normal> pddnd = new ProcessMessageDecorator<user_delete_deleteuser_normal>(pddn, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessUser_delete_deleteuser_normal");
//qo.SubscribeTopic<user_delete_deleteuser_normal, ProcessMessageDecorator<user_delete_deleteuser_normal>>(() => { return pddnd; }, "", "auth.exchange", "user_delete_deleteuser_normal", "user_delete_deleteuser_normal"); //普通消息
//ProcessUser_delete_deleteuser_normal_2 pddn2 = serviceProvider.GetRequiredService<ProcessUser_delete_deleteuser_normal_2>();
//ProcessMessageDecorator<user_delete_deleteuser_normal> pddnd2 = new ProcessMessageDecorator<user_delete_deleteuser_normal>(pddn2, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessUser_delete_deleteuser_normal2");
//qo.SubscribeTopic<user_delete_deleteuser_normal, ProcessMessageDecorator<user_delete_deleteuser_normal>>(() => { return pddnd2; }, "", "auth.exchange", "user_delete_deleteuser_normal", "user_delete_deleteuser_normal"); //普通消息
//ProcessUser_update_insertupdate_rpc puir = serviceProvider.GetRequiredService<ProcessUser_update_insertupdate_rpc>();
//ProcessMessageDecorator<user_update_insertupdate_rpc> puird = new ProcessMessageDecorator<user_update_insertupdate_rpc>(puir, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic user_update_insertupdate_rpc");
//qo.ResponseTopic<user_update_insertupdate_rpc, ProcessMessageDecorator<user_update_insertupdate_rpc>>(() => { return puird; }, "auth.exchange", "user_update_insertupdate_rpc", "user_update_insertupdate_rpc"); //普通消息
//ProcessUser_update_insertupdate_rpc_2 puir2 = serviceProvider.GetRequiredService<ProcessUser_update_insertupdate_rpc_2>();
//ProcessMessageDecorator<user_update_insertupdate_rpc> puird2 = new ProcessMessageDecorator<user_update_insertupdate_rpc>(puir2, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic user_update_insertupdate_rpc2");
//qo.ResponseTopic<user_update_insertupdate_rpc, ProcessMessageDecorator<user_update_insertupdate_rpc>>(() => { return puird2; }, "auth.exchange", "user_update_insertupdate_rpc", "user_update_insertupdate_rpc"); //普通消息
//ProcessUser_update_userroles_normal puun = serviceProvider.GetRequiredService<ProcessUser_update_userroles_normal>();
//ProcessMessageDecorator<user_update_userroles_normal> puund = new ProcessMessageDecorator<user_update_userroles_normal>(puun, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessUser_update_userroles_normal");
//qo.SubscribeTopic<user_update_userroles_normal, ProcessMessageDecorator<user_update_userroles_normal>>(() => { return puund; }, "", "auth.exchange", "user_update_userroles_normal", "user_update_userroles_normal"); //普通消息
////ProcessRole Role Operation Listener
//ProcessRoleRole_delete_deleterole_normal prddn = serviceProvider.GetRequiredService<ProcessRoleRole_delete_deleterole_normal>();
//ProcessMessageDecorator<role_delete_deleterole_normal> prddnd = new ProcessMessageDecorator<role_delete_deleterole_normal>(prddn, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessRoleRole_delete_deleterole_normal");
//qo.SubscribeTopic<role_delete_deleterole_normal, ProcessMessageDecorator<role_delete_deleterole_normal>>(() => { return prddnd; }, "", "auth.exchange", "role_delete_deleterole_normal", "role_delete_deleterole_normal"); //普通消息
//ProcessRoleRole_delete_others_normal prdon = serviceProvider.GetRequiredService<ProcessRoleRole_delete_others_normal>();
//ProcessMessageDecorator<role_delete_others_normal> prdond = new ProcessMessageDecorator<role_delete_others_normal>(prdon, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessRoleRole_delete_others_normal");
//qo.SubscribeTopic<role_delete_others_normal, ProcessMessageDecorator<role_delete_others_normal>>(() => { return prdond; }, "", "auth.exchange", "role_delete_others_normal", "role_delete_others_normal"); //普通消息
//ProcessRoleRole_update_insertupdate_rpc pruir = serviceProvider.GetRequiredService<ProcessRoleRole_update_insertupdate_rpc>();
//ProcessMessageDecorator<role_update_insertupdate_rpc> pruird = new ProcessMessageDecorator<role_update_insertupdate_rpc>(pruir, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessRoleRole_update_insertupdate_rpc");
//qo.ResponseTopic<role_update_insertupdate_rpc, ProcessMessageDecorator<role_update_insertupdate_rpc>>(() => { return pruird; }, "auth.exchange", "role_update_insertupdate_rpc", "role_update_insertupdate_rpc"); //普通消息
//ProcessRoleRole_update_others_normal pruon = serviceProvider.GetRequiredService<ProcessRoleRole_update_others_normal>();
//ProcessMessageDecorator<role_update_others_normal> pruond = new ProcessMessageDecorator<role_update_others_normal>(pruon, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessRoleRole_update_others_normal");
//qo.SubscribeTopic<role_update_others_normal, ProcessMessageDecorator<role_update_others_normal>>(() => { return pruond; }, "", "auth.exchange", "role_update_others_normal", "role_update_others_normal"); //普通消息
//ProcessRoleRole_update_rolemenus_normal prurn = serviceProvider.GetRequiredService<ProcessRoleRole_update_rolemenus_normal>();
//ProcessMessageDecorator<role_update_rolemenus_normal> prurnd = new ProcessMessageDecorator<role_update_rolemenus_normal>(prurn, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessRoleRole_update_rolemenus_normal");
//qo.SubscribeTopic<role_update_rolemenus_normal, ProcessMessageDecorator<role_update_rolemenus_normal>>(() => { return prurnd; }, "", "auth.exchange", "role_update_rolemenus_normal", "role_update_rolemenus_normal"); //普通消息
//ProcessRoleRole_rolemenus_others_normal pron = serviceProvider.GetRequiredService<ProcessRoleRole_rolemenus_others_normal>();
//ProcessMessageDecorator<role_rolemenus_others_normal> prond = new ProcessMessageDecorator<role_rolemenus_others_normal>(pron, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessRoleRole_rolemenus_others_normal");
//qo.SubscribeTopic<role_rolemenus_others_normal, ProcessMessageDecorator<role_rolemenus_others_normal>>(() => { return prond; }, "", "auth.exchange", "role_rolemenus_others_normal", "role_rolemenus_others_normal"); //普通消息
//ProcessMenu Menu Operation Listener
//ProcessMenuMenu_delete_deletemenu_normal pmddn = serviceProvider.GetRequiredService<ProcessMenuMenu_delete_deletemenu_normal>();
//ProcessMessageDecorator<menu_delete_deletemenu_normal> pmddnd = new ProcessMessageDecorator<menu_delete_deletemenu_normal>(pmddn, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessMenuMenu_delete_deletemenu_normal");
//qo.SubscribeTopic<menu_delete_deletemenu_normal, ProcessMessageDecorator<menu_delete_deletemenu_normal>>(() => { return pmddnd; }, "", "auth.exchange", "menu_delete_deletemenu_normal", "menu_delete_deletemenu_normal"); //普通消息
//ProcessMenuMenu_delete_others_normal pdon = serviceProvider.GetRequiredService<ProcessMenuMenu_delete_others_normal>();
//ProcessMessageDecorator<menu_delete_others_normal> pdond = new ProcessMessageDecorator<menu_delete_others_normal>(pdon, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessMenuMenu_delete_others_normal");
//qo.SubscribeTopic<menu_delete_others_normal, ProcessMessageDecorator<menu_delete_others_normal>>(() => { return pdond; }, "", "auth.exchange", "menu_delete_others_normal", "menu_delete_others_normal"); //普通消息
//ProcessMenuMenu_update_insertupdate_rpc pmuir = serviceProvider.GetRequiredService<ProcessMenuMenu_update_insertupdate_rpc>();
//ProcessMessageDecorator<menu_update_insertupdate_rpc> pmuird = new ProcessMessageDecorator<menu_update_insertupdate_rpc>(pmuir, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessMenuMenu_update_insertupdate_rpc");
//qo.ResponseTopic<menu_update_insertupdate_rpc, ProcessMessageDecorator<menu_update_insertupdate_rpc>>(() => { return pmuird; }, "auth.exchange", "menu_update_insertupdate_rpc", "menu_update_insertupdate_rpc"); //普通消息
//ProcessMenuMenu_update_others_normal pmuon = serviceProvider.GetRequiredService<ProcessMenuMenu_update_others_normal>();
//ProcessMessageDecorator<menu_update_others_normal> pmuond = new ProcessMessageDecorator<menu_update_others_normal>(pmuon, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessMenuMenu_update_others_normal");
//qo.ResponseTopic<menu_update_others_normal, ProcessMessageDecorator<menu_update_others_normal>>(() => { return pmuond; }, "auth.exchange", "menu_update_others_normal", "menu_update_others_normal"); //普通消息
//ProcessDepartment Department Operation Listener
//ProcessDepartmentDepartment_delete_deletedepartment_normal pdddn = serviceProvider.GetRequiredService<ProcessDepartmentDepartment_delete_deletedepartment_normal>();
//ProcessMessageDecorator<department_delete_deletedepartment_normal> pdddnd = new ProcessMessageDecorator<department_delete_deletedepartment_normal>(pdddn, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessDepartmentDepartment_delete_deletedepartment_normal");
//qo.SubscribeTopic<department_delete_deletedepartment_normal, ProcessMessageDecorator<department_delete_deletedepartment_normal>>(() => { return pdddnd; }, "", "auth.exchange", "department_delete_deletedepartment_normal", "department_delete_deletedepartment_normal"); //普通消息
//ProcessDepartmentDepartment_delete_others_normal pddon = serviceProvider.GetRequiredService<ProcessDepartmentDepartment_delete_others_normal>();
//ProcessMessageDecorator<department_delete_others_normal> pddond = new ProcessMessageDecorator<department_delete_others_normal>(pddon, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessDepartmentDepartment_delete_others_normal");
//qo.SubscribeTopic<department_delete_others_normal, ProcessMessageDecorator<department_delete_others_normal>>(() => { return pddond; }, "", "auth.exchange", "department_delete_others_normal", "department_delete_others_normal"); //普通消息
//ProcessDepartmentDepartment_update_insertupdate_rpc pduir = serviceProvider.GetRequiredService<ProcessDepartmentDepartment_update_insertupdate_rpc>();
//ProcessMessageDecorator<department_update_insertupdate_rpc> pduird = new ProcessMessageDecorator<department_update_insertupdate_rpc>(pduir, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessDepartmentDepartment_update_insertupdate_rpc");
//qo.ResponseTopic<department_update_insertupdate_rpc, ProcessMessageDecorator<department_update_insertupdate_rpc>>(() => { return pduird; }, "auth.exchange", "department_update_insertupdate_rpc", "department_update_insertupdate_rpc"); //普通消息
//ProcessDepartmentDepartment_update_others_normal pduon = serviceProvider.GetRequiredService<ProcessDepartmentDepartment_update_others_normal>();
//ProcessMessageDecorator<department_update_others_normal> pduond = new ProcessMessageDecorator<department_update_others_normal>(pduon, lockhandler);//分布式锁装饰类
//logger.Information("launch SubscribeTopic ProcessDepartmentDepartment_update_others_normal");
//qo.ResponseTopic<department_update_others_normal, ProcessMessageDecorator<department_update_others_normal>>(() => { return pduond; }, "auth.exchange", "department_update_others_normal", "department_update_others_normal"); //普通消息
#endregion
}
public virtual void Build(DomainMapper mapper, Formatter<PropertyInfo> formatter)
{
}
protected override async Task OutputToDatabaseBatchAsync(BlockingCollection <ReportOutputItem> reportOutputItems)
{
ExceptionDispatchInfo capturedException = null;
DbContextTransaction dbContextTransaction = null;
_logger.Info(string.Format("Outputting report items total of: {0}", reportOutputItems.Count));
if (reportOutputItems.Count == 0)
{
// Nothing to output
return;
}
// Cast to proper type
List <ActivationReportOutputItem> activationReportOutputItems = reportOutputItems.Select(
item => item as ActivationReportOutputItem).ToList();
try
{
// Create database context with the current correlation id
using (var dbContext = new DatabaseModel.CSPDatabaseModelEntities(_correlationId))
{
// Begin transaction
using (dbContextTransaction = dbContext.Database.BeginTransaction())
{
#region Batch insert in each table
// Customers
_logger.Info("Outputting customers ...");
// Customers
using (var dataCustomersManager = new DatabaseModel.Managers.CustomersManager(dbContext))
{
dataCustomersManager.AddOrUpdate(activationReportOutputItems
.Select(reportItem => CustomerMapper.MapFromSource(reportItem.Customer)));
}
// Domains
_logger.Info("Outputting customers domains ...");
using (var dataDomainsManager = new DatabaseModel.Managers.DomainsManager(dbContext))
{
dataDomainsManager.AddOrUpdate(activationReportOutputItems
.SelectMany(
reportItem => reportItem.CustomerDomains.Select(customerDomain =>
DomainMapper.MapFromSource(customerDomain, reportItem.Customer.Id))));
}
// Subscribed SKUs
_logger.Info("Outputting customers subscribed skus ...");
using (var dataSubscribedSKUsManager = new DatabaseModel.Managers.SubscribedSKUsManager(dbContext))
{
dataSubscribedSKUsManager.AddOrUpdate(activationReportOutputItems
.SelectMany(
reportItem => reportItem.CustomerSubscribedSkuAndSubscriptions
.Select(customerSubscribedSku => new DatabaseModel.SubscribedSKU()
{
Id = customerSubscribedSku.SubscribedSKU.ObjectId,
SkuBusinessId = customerSubscribedSku.SubscribedSKU.SkuId,
PartNumber = customerSubscribedSku.SubscribedSKU.SkuPartNumber,
OfferName =
// Check offer first
customerSubscribedSku.Offer != null ? customerSubscribedSku.Offer.Name : (
// Check subscribed sku part number
!string.IsNullOrWhiteSpace(customerSubscribedSku.SubscribedSKU.SkuPartNumber) ?
customerSubscribedSku.SubscribedSKU.SkuPartNumber : null),
CapabilityStatus = customerSubscribedSku.SubscribedSKU.CapabilityStatus,
CustomerId = Guid.Parse(reportItem.Customer.Id),
ActiveSeats = customerSubscribedSku.ActiveSeats,
InGracePeriodSeats = customerSubscribedSku.InGracePeriodSeats,
DisabledSeats = customerSubscribedSku.DisabledSeats,
AssignedSeats = customerSubscribedSku.AssignedSeats
})));
}
// Subscriptions
_logger.Info("Outputting customers subscribed skus associated subscriptions ...");
using (var dataSubscriptionsManager = new DatabaseModel.Managers.SubscriptionsManager(dbContext))
{
dataSubscriptionsManager.AddOrUpdate(activationReportOutputItems
.SelectMany(
reportItem => reportItem.CustomerSubscribedSkuAndSubscriptions
.SelectMany(customerSubscribedSku => customerSubscribedSku.SKUSubscriptions
.Select(subscribedSkuSubscription => SubscriptionMapper.MapFromSource(subscribedSkuSubscription,
reportItem.Customer.Id, customerSubscribedSku.SubscribedSKU.ObjectId)))));
}
// ActivationReport
_logger.Info("Outputting customers activation report ...");
// At the subscribed Skus level
using (var dataActivationReportsManager = new DatabaseModel.Managers.ActivationReportsManager(dbContext))
{
dataActivationReportsManager.AddActivationReports(activationReportOutputItems
.SelectMany(
reportItem => reportItem.CustomerSubscribedSkuAndSubscriptions
.Select(customerSubscribedSku => new DatabaseModel.ActivationReport()
{
CorrelationId = reportItem.CorrelationId,
CustomerId = Guid.Parse(reportItem.Customer.Id),
SubscribedSKUId = customerSubscribedSku.SubscribedSKU.ObjectId,
ActionType = customerSubscribedSku.ActionType,
ActionSubType = customerSubscribedSku.ActionSubType
})));
// At the customer (global) level
dataActivationReportsManager.AddActivationReports(activationReportOutputItems
.Where(
reportItem => !string.IsNullOrWhiteSpace(reportItem.GlobalActionType))
.Select(reportItem => new DatabaseModel.ActivationReport()
{
CorrelationId = reportItem.CorrelationId,
CustomerId = Guid.Parse(reportItem.Customer.Id),
ActionType = reportItem.GlobalActionType,
ActionSubType = reportItem.GlobalActionSubType
}));
}
#endregion
// Save changes andCommit transaction
await dbContext.SaveChangesAsync();
dbContextTransaction.Commit();
}
}
}
catch (DbEntityValidationException ex)
{
capturedException = ExceptionDispatchInfo.Capture(ex);
_logger.Warn("DbEntityValidationException: ");
foreach (var entityError in ex.EntityValidationErrors)
{
_logger.Warn("Entity error: " + string.Join(" / ", entityError.ValidationErrors.Select(e => e.PropertyName + " - " + e.ErrorMessage)));
}
if (dbContextTransaction != null)
{
// Rollback transaction
dbContextTransaction.Rollback();
}
}
catch (Exception ex)
{
capturedException = ExceptionDispatchInfo.Capture(ex);
_logger.Warn("Error: " + ex.ToString());
_logger.Warn("Inner Exception: " + ex.InnerException != null ? ex.InnerException.ToString() : "(empty)");
if (dbContextTransaction != null)
{
// Rollback transaction
dbContextTransaction.Rollback();
}
}
finally
{
//if (capturedException != null)
//{
// capturedException.Throw();
//}
}
}
