public void AddOrUpdateAllCacheKeyAppInfo(CacheKeyAppInfoModel model)
{
if (model.AppId.HasValue)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
var appInfo = this._efCacheKeyAppInfoRepository.GetById(model.AppId.Value);
appInfo.Code = model.Code;
appInfo.Name = model.Name;
appInfo.Desc = model.Desc;
this._efCacheKeyAppInfoRepository.Update(appInfo);
scope.SaveChanges();
}
}
else
{
this._efCacheKeyAppInfoRepository.Insert(new CacheKeyAppInfoEntity
{
Id = Guid.NewGuid(),
Code = model.Code,
CreateTime = DateTime.Now,
Desc = model.Desc,
Name = model.Name
});
}
}
public void SaveAuthFunctionInfoToRole(RoleFunctionInfoTreeModel model)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
var roleInfo = this._efAuthRoleInfoRepository.Table.Where(g => g.Id == model.RoleId).FirstOrDefault();
var appFuncs = roleInfo.AuthFunctionInfos.Where(func => func.AppId == model.AppId).ToList();
foreach (var item in appFuncs)
{
roleInfo.AuthFunctionInfos.Remove(item);
}
List <AuthFunctionInfoEntity> roleFuncs = new List <AuthFunctionInfoEntity>();
Dictionary <Guid, AuthFunctionInfoEntity> added = new Dictionary <Guid, AuthFunctionInfoEntity>();
foreach (var item in model.FunctionInfos)
{
var func = this._efAuthFunctionInfoRepository.GetById(item.Id);
var parents = GetALLParents(func, added);
roleFuncs.Add(func);
roleFuncs.AddRange(parents);
}
roleInfo.AuthFunctionInfos.AddRange(roleFuncs);
this._efAuthRoleInfoRepository.Update(roleInfo);
scope.SaveChanges();
}
}
public void AddOrUpdateAllAuthRoleInfo(AuthRoleInfoModel model)
{
if (model.RoleId.HasValue)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
var roleInfo = this._efAuthRoleInfoRepository.GetById(model.RoleId.Value);
roleInfo.Code = model.Code;
roleInfo.Name = model.Name;
roleInfo.IsEnable = model.IsEnable;
roleInfo.Desc = model.Desc;
roleInfo.UpdateTime = DateTime.Now;
this._efAuthRoleInfoRepository.Update(roleInfo);
scope.SaveChanges();
}
}
else
{
this._efAuthRoleInfoRepository.Insert(new AuthRoleInfoEntity
{
Id = Guid.NewGuid(),
Name = model.Name,
Code = model.Code,
Desc = model.Desc,
IsEnable = model.IsEnable,
UpdateTime = DateTime.Now,
CreateTime = DateTime.Now
});
}
}
public void AddOrUpdateAllSerialDefineInfo(SerialDefineInfoModel model)
{
if (model.Id.HasValue)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
var serInfo = this._efSerialDefineInfoRepository.GetById(model.Id.Value);
serInfo.Name = model.Name;
serInfo.Desc = model.Desc;
serInfo.ApplyCapacity = model.ApplyCapacity;
serInfo.CheckThreshold = model.CheckThreshold;
serInfo.DateFormat = model.DateFormat;
serInfo.FormatLength = model.FormatLength;
serInfo.PrefixValue = model.PrefixValue;
this._efSerialDefineInfoRepository.Update(serInfo);
scope.SaveChanges();
}
}
else
{
this._efSerialDefineInfoRepository.Insert(new SerialDefineInfoEntity
{
Id = Guid.NewGuid(),
Key = model.Key,
CreateTime = DateTime.Now,
Desc = model.Desc,
Name = model.Name,
PrefixValue = model.PrefixValue,
DateFormat = model.DateFormat,
ApplyCapacity = model.ApplyCapacity,
CheckThreshold = model.CheckThreshold,
FormatLength = model.FormatLength
});
}
}
public void AddAuthUserInfoToRole(Guid roleId, IList <Guid> idList)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
var roleInfo = this._efAuthRoleInfoRepository.Table.Where(g => g.Id == roleId).FirstOrDefault();
var userInfoList = this._efAuthUserInfoRepository.Table.Where(u => idList.Contains(u.Id)).ToList();
roleInfo.AuthUserInfos.AddRange(userInfoList);
this._efAuthRoleInfoRepository.Update(roleInfo);
scope.SaveChanges();
}
}
public bool DeleteAllCacheValueTypeItemInfo(IList <Guid> idList)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
foreach (var item in idList)
{
var itemInfo = this._efCacheValueTypeRepository.GetById(item);
this._efCacheValueTypeRepository.Delete(itemInfo);
}
scope.SaveChanges();
}
return(true);
}
public void RemoveAuthRoleInfoToGroup(Guid groupId, IList <Guid> idList)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
var groupInfo = this._efAuthGroupInfoRepository.Table.Where(g => g.Id == groupId).FirstOrDefault();
var roleInfoList = this._efAuthRoleInfoRepository.Table.Where(u => idList.Contains(u.Id)).ToList();
foreach (var item in roleInfoList)
{
groupInfo.AuthRoleInfos.Remove(item);
}
this._efAuthGroupInfoRepository.Update(groupInfo);
scope.SaveChanges();
}
}
public bool DeleteAllCacheKeyAssInfo(IList <Guid> idList)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
foreach (var item in idList)
{
var assInfo = this._efCacheKeyAssInfoRepository.GetById(item);
var count = this._efCacheValueTypeRepository.TableNoTracking.Where(key => key.AssId == assInfo.Id).Count();
if (count > 0)
{
return(false);
}
this._efCacheKeyAssInfoRepository.Delete(assInfo);
}
scope.SaveChanges();
}
return(true);
}
public bool DeleteAllAuthAppInfo(IList <Guid> idList)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
foreach (var item in idList)
{
var appInfo = this._efAuthAppInfoRepository.GetById(item);
var count = this._efAuthFunctionInfoRepository.TableNoTracking.Where(func => func.AppId == appInfo.Id).Count();
if (count > 0)
{
return(false);
}
this._efAuthAppInfoRepository.Delete(appInfo);
}
scope.SaveChanges();
}
return(true);
}
public bool DeleteAllAuthGroupInfo(IList <Guid> idList)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
foreach (var item in idList)
{
var db = this._efAuthGroupInfoRepository.TableNoTracking;
var userInfo = db.Include(u => u.AuthRoleInfos).Include(u => u.AuthUserInfos).Where(u => u.Id == item).FirstOrDefault();
if (userInfo != null)
{
userInfo.AuthRoleInfos.Clear();
userInfo.AuthUserInfos.Clear();
this._efAuthGroupInfoRepository.Delete(userInfo);
}
}
scope.SaveChanges();
}
return(true);
}
public bool DeleteAllAuthFunctionInfo(IList <Guid> idList)
{
using (var scope = AutoEfRepositoryFactory.GetEfRepositoryFactory(DataSources.DataSource_ItAdmin).CreateReadWriteContextScope())
{
foreach (var item in idList)
{
var db = this._efAuthFunctionInfoRepository.TableNoTracking;
var count = db.Where(func => func.ParentId == item).Count();
if (count > 0)
{
return(false);
}
var funcInfo = db.Include(func => func.AuthRoleInfos).Where(func => func.Id == item).FirstOrDefault();
if (funcInfo != null)
{
funcInfo.AuthRoleInfos.Clear();
this._efAuthFunctionInfoRepository.Delete(funcInfo);
}
}
scope.SaveChanges();
}
return(true);
}
/// <summary>
/// Register dependencies
/// </summary>
/// <param name="config">Config</param>
protected virtual void RegisterDependencies()
{
var builder = new ContainerBuilder();
var container = builder.Build();
//we create new instance of ContainerBuilder
//because Build() or Update() method can only be called once on a ContainerBuilder.
builder = new ContainerBuilder();
builder.RegisterInstance(this).As <IEngine>().SingleInstance();
builder.RegisterInstance(_typeFinder).As <ITypeFinder>().SingleInstance();
builder.Update(container);
//register dependencies provided by other assemblies
builder = new ContainerBuilder();
var drTypes = _typeFinder.FindClassesOfType <IDependencyRegistrar>();
var drInstances = new List <IDependencyRegistrar>();
foreach (var drType in drTypes)
{
drInstances.Add((IDependencyRegistrar)Activator.CreateInstance(drType));
}
drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList();
foreach (var dependencyRegistrar in drInstances)
{
logger.Info(string.Format("发现自动对象注册器，类型：{0}", dependencyRegistrar.GetType().FullName));
dependencyRegistrar.Register(builder, _typeFinder);
}
logger.Info(string.Format("成功注册自动对象注册器{0}个", drInstances.Count));
builder.Update(container);
builder = new ContainerBuilder();
//发现自动服务
var autoDataServiceTypes = _typeFinder.FindClassesOfAttribute <AutoDataServiceAttribute>(false);
foreach (var item in autoDataServiceTypes)
{
var service = item.GetCustomAttribute <AutoDataServiceAttribute>();
if (service.ServiceType == AutoDataServiceType.Mapping)
{
logger.Info(string.Format("发现ibatis数据服务对象，类型：{0}", item.FullName));
var instance = AutoDataAccessFactory.GetDataAccess(item);
builder.RegisterInstance(instance).As(item).SingleInstance();
}
else
{
logger.Info(string.Format("发现EF数据服务对象，类型：{0}", item.FullName));
var instance = AutoEfRepositoryFactory.GetEfRepository(item);
var instanceType = typeof(IRepository <>).MakeGenericType(item);
builder.RegisterInstance(instance).As(instanceType).SingleInstance();
}
}
logger.Info(string.Format("成功注册数据服务对象{0}个", autoDataServiceTypes.Count()));
var autoBizServiceTypes = _typeFinder.FindClassesOfAttribute <AutoBizServiceAttribute>(false);
foreach (var item in autoBizServiceTypes)
{
var ifaceName = item.FullName.Replace("." + item.Name, ".I" + item.Name);
Type ifaceType = Type.GetType(ifaceName + "," + item.Assembly.FullName);
if (ifaceType != null)
{
logger.Info(string.Format("发现业务服务对象，类型：{0}，接口类型：{1}", item.FullName, ifaceType.FullName));
builder.RegisterType(item).As(ifaceType).SingleInstance();
}
else
{
logger.Info(string.Format("发现业务服务对象，类型：{0}", item.FullName));
builder.RegisterType(item).SingleInstance();
}
}
logger.Info(string.Format("成功注册业务服务对象{0}个", autoBizServiceTypes.Count()));
if (SubscriptionManager.IsPublisherContextInitialize)
{
logger.Info("事件发布上下文已开启，开始注册事件发布接口IEventPublisher");
//注册本地事件通知服务
builder.RegisterInstance(SubscriptionManager.Publisher).As(typeof(Ik.Framework.Events.IEventPublisher)).SingleInstance();
}
builder.Update(container);
this._containerManager = CreateContainerManager(container);
}
