public List <UserRoleItem> GetUserRoles(User user)
{
var parameters = new List <DbQueryParameter>()
{
new DbQueryParameter("InsCode", user.InsCode),
new DbQueryParameter("UserId", user.Id)
};
List <UserRoleItem> userRoleItems = new List <UserRoleItem>();
var result = SqlDbManager.Instance().ExecuteProcedureDataSets(UserSpHelper.GetUserRolesSpName(), parameters, SqlDbManager.SqlConnectionMode.QUERYBOOK);
if (result != null)
{
if (result.Tables.Count > 0 && result.Tables[0].Rows.Count > 0)
{
foreach (DataRow item in result.Tables[0].Rows)
{
UserRoleItem userRoleItem = new UserRoleItem {
RoleName = item["RoleName"].ToString()
};
userRoleItems.Add(userRoleItem);
}
}
}
return(userRoleItems);
}
public Institution Add(Institution entity)
{
List <DbQueryParameter> parameter = new List <DbQueryParameter>()
{
new DbQueryParameter("Code", string.IsNullOrEmpty(entity.Code)?"":entity.Code),
new DbQueryParameter("Name", string.IsNullOrEmpty(entity.Name)?"":entity.Name),
new DbQueryParameter("Email", string.IsNullOrEmpty(entity.Email)?"":entity.Email),
new DbQueryParameter("Tel01", string.IsNullOrEmpty(entity.Tel01)?"":entity.Tel01),
new DbQueryParameter("Tel02", string.IsNullOrEmpty(entity.Tel02)?"":entity.Tel02),
new DbQueryParameter("Tel03", string.IsNullOrEmpty(entity.Tel03)?"":entity.Tel03),
new DbQueryParameter("Tel04", string.IsNullOrEmpty(entity.Tel04)?"":entity.Tel04),
new DbQueryParameter("Fax01", string.IsNullOrEmpty(entity.Fax01)?"":entity.Fax02),
new DbQueryParameter("Fax02", string.IsNullOrEmpty(entity.Fax02)?"":entity.Fax02),
new DbQueryParameter("Fax03", string.IsNullOrEmpty(entity.Fax03)?"":entity.Fax03),
new DbQueryParameter("Fax04", string.IsNullOrEmpty(entity.Fax04)?"":entity.Fax04),
new DbQueryParameter("Address", string.IsNullOrEmpty(entity.Address)?"":entity.Address),
new DbQueryParameter("Explanation", string.IsNullOrEmpty(entity.Explanation)?"":entity.Explanation),
new DbQueryParameter("WebSite01", string.IsNullOrEmpty(entity.WebSite01)?"":entity.WebSite01),
new DbQueryParameter("WebSite02", string.IsNullOrEmpty(entity.WebSite02)?"":entity.WebSite02),
new DbQueryParameter("WebSite03", string.IsNullOrEmpty(entity.WebSite03)?"":entity.WebSite03),
new DbQueryParameter("WebSite04", string.IsNullOrEmpty(entity.WebSite04)?"":entity.WebSite04),
new DbQueryParameter("LogoPath", string.IsNullOrEmpty(entity.LogoPath)?"":entity.LogoPath),
new DbQueryParameter("BannerPath", string.IsNullOrEmpty(entity.BannerPath)?"":entity.BannerPath)
};
return(SqlDbManager.Instance().ExecuteSingle <Institution>(InstutionSpHelper.AddUpName(), parameter, SqlDbManager.SqlConnectionMode.QUERYBOOK));
}
public User Get(User filter)
{
var parameters = new List <DbQueryParameter>()
{
new DbQueryParameter("InsCode", filter.InsCode),
new DbQueryParameter("Email", filter.Email)
};
return(LoadDataSetUser(SqlDbManager.Instance().ExecuteProcedureDataSets(UserSpHelper.GetSpName(), parameters, SqlDbManager.SqlConnectionMode.QUERYBOOK)));
}
///--------------------------------------------------------------------------------
/// <summary>Interpret this node to produce code, output, or model data..</summary>
///
/// <param name="interpreterType">The type of interpretation to perform.</param>
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
///--------------------------------------------------------------------------------
public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext)
{
try
{
int itemIndex = 0;
templateContext.ItemIndex = itemIndex;
if (ForeachClause.ForeachHelperName == LanguageTerms.RecordItem)
{
bool isValidContext;
Entity entityContext = Entity.GetModelContext(solutionContext, modelContext, out isValidContext) as Entity;
if (entityContext != null)
{
templateContext.PushModelContext(entityContext);
SqlDbManager manager = new SqlDbManager(new DatabaseOptions(solutionContext.SourceDbServerName, solutionContext.SourceDbName));
string sqlStatement = "SELECT * FROM " + entityContext.DBTableName;
templateContext.DbReader = manager.ExecuteRawSqlReader(sqlStatement);
while (templateContext.DbReader.Read())
{
if (ForeachClause.LimitClause == null || ForeachClause.LimitClause.Limit >= itemIndex + 1)
{
templateContext.IsBreaking = false;
templateContext.IsContinuing = false;
foreach (IStatementNode node in Statements)
{
if (node.HandleDebug(interpreterType, solutionContext, templateContext, entityContext) == false)
{
return;
}
if (templateContext.IsContinuing == true)
{
break;
}
if (templateContext.IsBreaking == true || templateContext.IsReturning == true)
{
templateContext.IsBreaking = false;
break;
}
if (node is BreakStatementNode)
{
templateContext.IsBreaking = true;
break;
}
if (node is ContinueStatementNode)
{
break;
}
if (node is ReturnStatementNode)
{
templateContext.IsReturning = true;
break;
}
node.InterpretNode(interpreterType, solutionContext, templateContext, modelContext);
}
itemIndex++;
templateContext.ItemIndex = itemIndex;
}
}
manager.Close();
manager = null;
templateContext.DbReader = null;
templateContext.PopModelContext();
}
}
else
{
IEnterpriseEnumerable collection = GetCollection(solutionContext, templateContext, modelContext, interpreterType);
if (collection != null)
{
foreach (IDomainEnterpriseObject itemContext in collection)
{
templateContext.PushModelContext(itemContext);
if (templateContext.IsBreaking == true || templateContext.IsReturning == true)
{
templateContext.IsBreaking = false;
break;
}
if (ForeachClause.WhereClause == null || ForeachClause.WhereClause.Expression.EvaluateExpression(solutionContext, templateContext, itemContext, interpreterType) == true)
{
if (ForeachClause.LimitClause == null || ForeachClause.LimitClause.Limit >= itemIndex + 1)
{
templateContext.IsBreaking = false;
templateContext.IsContinuing = false;
foreach (IStatementNode node in Statements)
{
if (node.HandleDebug(interpreterType, solutionContext, templateContext, itemContext) == false)
{
return;
}
if (templateContext.IsContinuing == true)
{
break;
}
if (templateContext.IsBreaking == true || templateContext.IsReturning == true)
{
templateContext.IsBreaking = false;
break;
}
if (node is BreakStatementNode)
{
templateContext.IsBreaking = true;
break;
}
if (node is ContinueStatementNode)
{
break;
}
if (node is ReturnStatementNode)
{
templateContext.IsReturning = true;
break;
}
node.InterpretNode(interpreterType, solutionContext, templateContext, itemContext);
}
}
itemIndex++;
templateContext.ItemIndex = itemIndex;
}
templateContext.PopModelContext();
}
}
templateContext.IsBreaking = false;
}
templateContext.ItemIndex = 0;
}
catch (ApplicationAbortException)
{
throw;
}
catch (System.Exception ex)
{
LogException(solutionContext, templateContext, modelContext, ex, interpreterType);
}
}
/// <summary>
/// Register dependencies
/// </summary>
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.
//register engine
builder = new ContainerBuilder();
builder.RegisterInstance(this).As <IEngine>().SingleInstance();
//register controllers
builder.RegisterControllers(Assembly.GetExecutingAssembly());
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
//register http context
builder.Register(c => new HttpContextWrapper(HttpContext.Current) as HttpContextBase).As <HttpContextBase>().InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Request).As <HttpRequestBase>().InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Response).As <HttpResponseBase>().InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Server).As <HttpServerUtilityBase>().InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Session).As <HttpSessionStateBase>().InstancePerLifetimeScope();
//register core class
builder.RegisterType <WebHelper>().As <IWebHelper>().InstancePerLifetimeScope();
builder.RegisterType <SqliteDataProvider>().As <IDataProvider>().SingleInstance();
builder.RegisterType <SqlDbManager>().As <IDbManager>().SingleInstance();
builder.RegisterType <DbInstaller>().As <IDbInstaller>().SingleInstance();
builder.RegisterType <RedisCacheManager>().As <ICacheManager>().SingleInstance();
builder.RegisterType <ExcelManager>().As <IExcelManager>().SingleInstance();
builder.RegisterType <ServiceGetter>().As <IServiceGetter>().SingleInstance();
builder.RegisterType <iPemWorkContext>().As <IWorkContext>().InstancePerLifetimeScope();
builder.RegisterType <ApiWorkContext>().As <IApiWorkContext>().InstancePerApiRequest();
//register bi class
builder.RegisterType <SCPackMgr>().As <IPackMgr>().InstancePerLifetimeScope();
var dbManager = new SqlDbManager(new SqliteDataProvider());
if (dbManager.IsValid(EnmDbType.Rs))
{
var connectionString = dbManager.CurrentConnetions[EnmDbType.Rs];
//register executor
builder.Register <IRsExecutor>(c => new RsExecutor(connectionString, c.Resolve <IDbInstaller>())).InstancePerLifetimeScope();
//register repository
builder.Register <IA_AreaRepository>(c => new A_AreaRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_BrandRepository>(c => new C_BrandRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_DepartmentRepository>(c => new C_DepartmentRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_DeviceTypeRepository>(c => new C_DeviceTypeRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_DutyRepository>(c => new C_DutyRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_EnumMethodRepository>(c => new C_EnumMethodRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_FtpRepository>(c => new C_FtpRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_GroupRepository>(c => new C_GroupRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_LogicTypeRepository>(c => new C_LogicTypeRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_ProductorRepository>(c => new C_ProductorRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_RoomTypeRepository>(c => new C_RoomTypeRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_SCVendorRepository>(c => new C_SCVendorRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_StationTypeRepository>(c => new C_StationTypeRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_SubCompanyRepository>(c => new C_SubCompanyRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_SupplierRepository>(c => new C_SupplierRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IC_UnitRepository>(c => new C_UnitRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <ID_DeviceRepository>(c => new D_DeviceRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <ID_FsuRepository>(c => new D_FsuRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <ID_RedefinePointRepository>(c => new D_RedefinePointRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <ID_SignalRepository>(c => new D_SignalRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_MaskingRepository>(c => new H_MaskingRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_NoteRepository>(c => new H_NoteRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IM_AuthorizationRepository>(c => new M_AuthorizationRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IM_CardRepository>(c => new M_CardRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IP_PointRepository>(c => new P_PointRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IP_ProtocolRepository>(c => new P_ProtocolRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IR_DBScriptRepository>(c => new R_DBScriptRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IS_RoomRepository>(c => new S_RoomRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IS_StationRepository>(c => new S_StationRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IU_EmployeeRepository>(c => new U_EmployeeRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_CameraRepository>(c => new V_CameraRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_ChannelRepository>(c => new V_ChannelRepository(connectionString)).InstancePerLifetimeScope();
//默认UserRepository
//builder.Register<IU_UserRepository>(c => new iPem.Data.Repository.Rs.U_UserRepository(connectionString)).InstancePerLifetimeScope();
//指定名称的UserRepository
builder.Register(c => new iPem.Data.Repository.Rs.U_UserRepository(connectionString)).Named <IU_UserRepository>("rs_user_repository").InstancePerLifetimeScope();
//register service
builder.RegisterType <AreaService>().As <IAreaService>().InstancePerLifetimeScope();
builder.RegisterType <BrandService>().As <IBrandService>().InstancePerLifetimeScope();
builder.RegisterType <CameraService>().As <ICameraService>().InstancePerLifetimeScope();
builder.RegisterType <ChannelService>().As <IChannelService>().InstancePerLifetimeScope();
builder.RegisterType <DepartmentService>().As <IDepartmentService>().InstancePerLifetimeScope();
builder.RegisterType <DeviceService>().As <IDeviceService>().InstancePerLifetimeScope();
builder.RegisterType <DeviceTypeService>().As <IDeviceTypeService>().InstancePerLifetimeScope();
builder.RegisterType <DutyService>().As <IDutyService>().InstancePerLifetimeScope();
builder.RegisterType <EmployeeService>().As <IEmployeeService>().InstancePerLifetimeScope();
builder.RegisterType <EnumMethodService>().As <IEnumMethodService>().InstancePerLifetimeScope();
builder.RegisterType <GroupService>().As <IGroupService>().InstancePerLifetimeScope();
builder.RegisterType <FsuService>().As <IFsuService>().InstancePerLifetimeScope();
builder.RegisterType <FtpService>().As <IFtpService>().InstancePerLifetimeScope();
builder.RegisterType <LogicTypeService>().As <ILogicTypeService>().InstancePerLifetimeScope();
builder.RegisterType <MaskingService>().As <IMaskingService>().InstancePerLifetimeScope();
builder.RegisterType <PointService>().As <IPointService>().InstancePerLifetimeScope();
builder.RegisterType <ProductorService>().As <IProductorService>().InstancePerLifetimeScope();
builder.RegisterType <ProtocolService>().As <IProtocolService>().InstancePerLifetimeScope();
builder.RegisterType <RDBScriptService>().As <IRDBScriptService>().InstancePerLifetimeScope();
builder.RegisterType <RedefinePointService>().As <IRedefinePointService>().InstancePerLifetimeScope();
builder.RegisterType <MAuthorizationService>().As <IMAuthorizationService>().InstancePerLifetimeScope();
builder.RegisterType <MCardService>().As <IMCardService>().InstancePerLifetimeScope();
builder.RegisterType <NoteService>().As <INoteService>().InstancePerLifetimeScope();
builder.RegisterType <RoomService>().As <IRoomService>().InstancePerLifetimeScope();
builder.RegisterType <RoomTypeService>().As <IRoomTypeService>().InstancePerLifetimeScope();
builder.RegisterType <SCVendorService>().As <ISCVendorService>().InstancePerLifetimeScope();
builder.RegisterType <SignalService>().As <ISignalService>().InstancePerLifetimeScope();
builder.RegisterType <StationService>().As <IStationService>().InstancePerLifetimeScope();
builder.RegisterType <StationTypeService>().As <IStationTypeService>().InstancePerLifetimeScope();
builder.RegisterType <SubCompanyService>().As <ISubCompanyService>().InstancePerLifetimeScope();
builder.RegisterType <SupplierService>().As <ISupplierService>().InstancePerLifetimeScope();
builder.RegisterType <UnitService>().As <IUnitService>().InstancePerLifetimeScope();
//builder.RegisterType<iPem.Services.Rs.UserService>().As<IUserService>().InstancePerLifetimeScope();
}
if (dbManager.IsValid(EnmDbType.Cs))
{
var connectionString = dbManager.CurrentConnetions[EnmDbType.Cs];
//register executor
builder.Register <ICsExecutor>(c => new CsExecutor(connectionString, c.Resolve <IDbInstaller>())).InstancePerLifetimeScope();
//register repository
builder.Register <IA_AAlarmRepository>(c => new A_AAlarmRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IA_TAlarmRepository>(c => new A_TAlarmRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IA_HAlarmRepository>(c => new A_HAlarmRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_CardRecordRepository>(c => new H_CardRecordRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_DBScriptRepository>(c => new H_DBScriptRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_FsuEventRepository>(c => new H_FsuEventRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_IAreaRepository>(c => new H_IAreaRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_IDeviceRepository>(c => new H_IDeviceRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_IStationRepository>(c => new H_IStationRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_ACabinetRepository>(c => new V_ACabinetRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_AMeasureRepository>(c => new V_AMeasureRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_BatCurveRepository>(c => new V_BatCurveRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_BatRepository>(c => new V_BatRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_BatTimeRepository>(c => new V_BatTimeRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_OfflineRepository>(c => new V_OfflineRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_ElecRepository>(c => new V_ElecRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_HMeasureRepository>(c => new V_HMeasureRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_LoadRepository>(c => new V_LoadRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_ParamDiffRepository>(c => new V_ParamDiffRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IV_StaticRepository>(c => new V_StaticRepository(connectionString)).InstancePerLifetimeScope();
//register service
builder.RegisterType <AAlarmService>().As <IAAlarmService>().InstancePerLifetimeScope();
builder.RegisterType <ACabinetService>().As <IACabinetService>().InstancePerLifetimeScope();
builder.RegisterType <AMeasureService>().As <IAMeasureService>().InstancePerLifetimeScope();
builder.RegisterType <BatCurveService>().As <IBatCurveService>().InstancePerLifetimeScope();
builder.RegisterType <BatService>().As <IBatService>().InstancePerLifetimeScope();
builder.RegisterType <BatTimeService>().As <IBatTimeService>().InstancePerLifetimeScope();
builder.RegisterType <CardRecordService>().As <ICardRecordService>().InstancePerLifetimeScope();
builder.RegisterType <OfflineService>().As <IOfflineService>().InstancePerLifetimeScope();
builder.RegisterType <ElecService>().As <IElecService>().InstancePerLifetimeScope();
builder.RegisterType <FsuEventService>().As <IFsuEventService>().InstancePerLifetimeScope();
builder.RegisterType <HAlarmService>().As <IHAlarmService>().InstancePerLifetimeScope();
builder.RegisterType <HDBScriptService>().As <IHDBScriptService>().InstancePerLifetimeScope();
builder.RegisterType <HIAreaService>().As <IHIAreaService>().InstancePerLifetimeScope();
builder.RegisterType <HIDeviceService>().As <IHIDeviceService>().InstancePerLifetimeScope();
builder.RegisterType <HIStationService>().As <IHIStationService>().InstancePerLifetimeScope();
builder.RegisterType <HMeasureService>().As <IHMeasureService>().InstancePerLifetimeScope();
builder.RegisterType <LoadRateService>().As <ILoadService>().InstancePerLifetimeScope();
builder.RegisterType <ParamDiffService>().As <IParamDiffService>().InstancePerLifetimeScope();
builder.RegisterType <StaticService>().As <IStaticService>().InstancePerLifetimeScope();
builder.RegisterType <TAlarmService>().As <ITAlarmService>().InstancePerLifetimeScope();
}
if (dbManager.IsValid(EnmDbType.Sc))
{
var connectionString = dbManager.CurrentConnetions[EnmDbType.Sc];
//register executor
builder.Register <IScExecutor>(c => new ScExecutor(connectionString, c.Resolve <IDbInstaller>())).InstancePerLifetimeScope();
//register repository
builder.Register <IG_ImageRepository>(c => new G_ImageRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IG_PageRepository>(c => new G_PageRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IG_TemplateRepository>(c => new G_TemplateRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_NoticeInUserRepository>(c => new H_NoticeInUserRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_NoticeRepository>(c => new H_NoticeRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IH_WebEventRepository>(c => new H_WebEventRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IM_DictionaryRepository>(c => new M_DictionaryRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IM_FormulaRepository>(c => new M_FormulaRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IM_NodesInReservationRepository>(c => new M_NodesInReservationRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IM_ProjectRepository>(c => new M_ProjectRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IM_ReservationRepository>(c => new M_ReservationRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IS_DBScriptRepository>(c => new S_DBScriptRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IU_EntitiesInRoleRepository>(c => new U_EntitiesInRoleRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IU_MenuRepository>(c => new U_MenuRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IU_ProfileRepository>(c => new U_ProfileRepository(connectionString)).InstancePerLifetimeScope();
builder.Register <IU_RoleRepository>(c => new U_RoleRepository(connectionString)).InstancePerLifetimeScope();
//默认UserRepository
builder.Register <IU_UserRepository>(c => new iPem.Data.Repository.Sc.U_UserRepository(connectionString)).InstancePerLifetimeScope();
//指定名称的UserRepository
builder.Register(c => new iPem.Data.Repository.Sc.U_UserRepository(connectionString)).Named <IU_UserRepository>("sc_user_repository").InstancePerLifetimeScope();
//register service
builder.RegisterType <DictionaryService>().As <IDictionaryService>().InstancePerLifetimeScope();
builder.RegisterType <EntitiesInRoleService>().As <IEntitiesInRoleService>().InstancePerLifetimeScope();
builder.RegisterType <FormulaService>().As <IFormulaService>().InstancePerLifetimeScope();
builder.RegisterType <GImageService>().As <IGImageService>().InstancePerLifetimeScope();
builder.RegisterType <GPageService>().As <IGPageService>().InstancePerLifetimeScope();
builder.RegisterType <GTemplateService>().As <IGTemplateService>().InstancePerLifetimeScope();
builder.RegisterType <MenuService>().As <IMenuService>().InstancePerLifetimeScope();
builder.RegisterType <NodeInReservationService>().As <INodeInReservationService>().InstancePerLifetimeScope();
builder.RegisterType <NoticeInUserService>().As <INoticeInUserService>().InstancePerLifetimeScope();
builder.RegisterType <NoticeService>().As <INoticeService>().InstancePerLifetimeScope();
builder.RegisterType <ProfileService>().As <IProfileService>().InstancePerLifetimeScope();
builder.RegisterType <ProjectService>().As <IProjectService>().InstancePerLifetimeScope();
builder.RegisterType <ReservationService>().As <IReservationService>().InstancePerLifetimeScope();
builder.RegisterType <RoleService>().As <IRoleService>().InstancePerLifetimeScope();
builder.RegisterType <SDBScriptService>().As <ISDBScriptService>().InstancePerLifetimeScope();
builder.RegisterType <WebEventService>().As <IWebEventService>().InstancePerLifetimeScope();
builder.RegisterType <iPem.Services.Sc.UserService>().As <IUserService>().InstancePerLifetimeScope();
}
builder.Update(container);
this._containerManager = new ContainerManager(container);
//set mvc dependency resolver
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
//set webapi dependency resolver
GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
}
public SqlNodeRepository(string connectionString)
{
this._sqlDBManager = new SqlDbManager(connectionString);
}
