public AccessSchemaProvider(IConnectionProvider connectionProvider) { if (connectionProvider == null) throw new ArgumentNullException("connectionProvider"); _connectionProvider = connectionProvider; }
/// <summary> /// Creates and executes query using the given ConnectionProvider. /// </summary> /// <param name="conn">Connection provider.</param> /// <param name="cmdText">Command text.</param> /// <param name="parameters">Command parameters.</param> /// <param name="cmdType">Command type (stored procedure or text).</param> /// <param name="cmdTimeout">Set timeout for specified command.</param> /// <param name="dataTableName">Name of the datatable that will be returned. May be null.</param> /// <returns>DataTable containing retrieved data.</returns> public static DataTable ExecuteQuery(IConnectionProvider conn, string cmdText, DbParameterCollection parameters, CommandType cmdType, string dataTableName, int cmdTimeout) { IDbCommand cmd = CreateCommand(conn.DBMS, cmdText, parameters, cmdType, cmdTimeout); cmd.Connection = conn.Connection; IDataAdapterBuilder builder = DbmsComponentFactory.GetComponent<IDataAdapterBuilder>(conn.DBMS); IDataAdapter adapter = builder.BuildAdapter(cmd); bool connIsOpennedLocally = EnsureOpenConnection(conn); try { AssignExistingPendingTransactionToCommand(conn, cmd); // Execute query. DataSet data = new DataSet(); data.Locale = CultureInfo.InvariantCulture; adapter.Fill(data); PopulateOutputParameterValues(parameters, cmd); DataTable table = (data.Tables.Count > 0) ? data.Tables[0] : new DataTable() { Locale = CultureInfo.InvariantCulture }; if (!string.IsNullOrEmpty(dataTableName)) table.TableName = dataTableName; return table; } finally { CloseConnectionIfLocal(conn, connIsOpennedLocally); cmd.Dispose(); IDisposable disposableAdapter = adapter as IDisposable; if (disposableAdapter != null) disposableAdapter.Dispose(); } }
protected virtual string Execute(IQuery query, IDictionary<string, string> parameters, IConnectionProvider provider) { using (IDbConnection connection = provider.CreateConnection()) using (var builder = new CommandBuilder(connection)) { builder .SetText(query.QueryText) .SetType(GetCommandType(query.Options)) .SetTimeout(query.Options .GetInteger(Strings.kCommandTimeoutOption, 30)); BindParameters(builder, query.Parameters, parameters); string preferred_json_collection = query.Options .GetString(Strings.kJsonCollectionOption, Strings.kDefaultJsonCollection); IDbCommand cmd = builder.Build(); connection.Open(); string response = (query.QueryMethod == QueryMethod.Get) ? ExecuteReader(cmd, query, preferred_json_collection) : ExecuteNonQuery(cmd, query, preferred_json_collection); connection.Close(); return response; } }
public void SetUp() { provider = MockRepository.GenerateMock<IConnectionProvider>(); connection = MockRepository.GenerateMock<IDbConnection>(); command = MockRepository.GenerateMock<IDbCommand>(); reader = MockRepository.GenerateMock<IDataReader>(); }
private ISchemaProvider GetExpectedSchemaProvider(IConnectionProvider connectionProvider) { var serverVersion = GetServerVersion(connectionProvider); if (!string.IsNullOrEmpty(serverVersion) && serverVersion.StartsWith("5")) return new MysqlSchemaProvider(connectionProvider, new MysqlSchemaDataProvider50(connectionProvider)); return new MysqlSchemaProvider(connectionProvider, new MysqlSchemaDataProvider40(connectionProvider)); }
/// <summary>Executes <see cref="UpdateStatement"/>. Bulk updates are executed in multiple round trips - one update at a time.</summary> public int Execute(UpdateStatement update, DbmsType dbms, IConnectionProvider conn, out CommandExecutionStatistics lastExecutedCommandInfo, int cmdTimeout = 30) { if (IsBulkUpdate(update)) return ExecuteBulkUpdate(update, dbms, conn, out lastExecutedCommandInfo, cmdTimeout); else return ExecuteSingleTableUpdate(update, dbms, conn, out lastExecutedCommandInfo, cmdTimeout); }
private static bool EnsureOpenConnection(IConnectionProvider conn) { bool connIsOpennedLocally = !conn.IsOpen; if (connIsOpennedLocally) conn.OpenConnection(); return connIsOpennedLocally; }
protected override void OnSetup() { var settingsKeys = ((IDictionary<string, object>) Settings).Keys; if (settingsKeys.Contains("ConnectionString")) { if (settingsKeys.Contains("ProviderName")) { _connectionProvider = ProviderHelper.GetProviderByConnectionString(Settings.ConnectionString, Settings.ProviderName); } else { _connectionProvider = ProviderHelper.GetProviderByConnectionString(Settings.ConnectionString); } } else if (settingsKeys.Contains("Filename")) { _connectionProvider = ProviderHelper.GetProviderByFilename(Settings.Filename); } else if (settingsKeys.Contains("ConnectionName")) { _connectionProvider = ProviderHelper.GetProviderByConnectionName(Settings.ConnectionName); } _schema = DatabaseSchema.Get(_connectionProvider, _providerHelper); _relatedFinder = new Lazy<AdoAdapterRelatedFinder>(CreateRelatedFinder); _commandOptimizer = ProviderHelper.GetCustomProvider<CommandOptimizer>(_connectionProvider) ?? new CommandOptimizer(); }
public ESSession(IConnectionProvider connectionProvider) { if (Current != null) throw new ElasticSearchException("Cannot create a new session while there is one already active."); ConnectionProvider = connectionProvider; Current = this; }
public GetCitiesNames( IConnectionProvider connectionProvider, IEventAggregator eventAggregator) { _connectionProvider = connectionProvider; _eventAggregator = eventAggregator; }
public FlumeSession(IConnectionProvider connectionProvider) { if (Current != null) throw new BrokenCollectorException("Cannot create a new session while there is one already active."); ConnectionProvider = connectionProvider; Current = this; }
public GetReservationsForUser( IConnectionProvider connectionProvider, IEventAggregator eventAggregator) { _connectionProvider = connectionProvider; _eventAggregator = eventAggregator; }
private static IEntityDAO GetDao(IConnectionProvider conn, IEntity entity, IEntityDaoFactory daoFactory) { if (daoFactory != null) return daoFactory.GetEntityDAO(entity, conn); else return DefaultDaoFactory.GetEntityDAO(entity, conn); }
public ClusterHeartBeat(Cluster cluster, IConnectionProvider provider, TimeSpan pollingInterval) { Cluster = cluster; NodeChecks = new Dictionary<INode, IFixedSizeStack<ConnectivityCheck>>(); ConnectionProvider = provider; PollingInterval = pollingInterval; }
public override bool TryGetProvider(string connectionString, out IConnectionProvider provider, out Exception exception) { try { var _ = new SqlConnectionStringBuilder(connectionString); } catch (KeyNotFoundException ex) { exception = ex; provider = null; return false; } catch (FormatException ex) { exception = ex; provider = null; return false; } catch (ArgumentException ex) { exception = ex; provider = null; return false; } provider = new SqlConnectionProvider(connectionString); exception = null; return true; }
public AttributeTypeRepository(IConnectionProvider connectionProvider, IDataTypeConverter dataTypeConverter, IEntityAttributeTypeRepository entityAttributeTypeRepository) { _connectionProvider = connectionProvider; _dataTypeConverter = dataTypeConverter; _entityAttributeTypeRepository = entityAttributeTypeRepository; }
public void Initialize(MigrationContext context) { _configuration = context.Configuration; _schemaProvider = context.SchemaProvider; _databaseProvider = context.DatabaseProvider; _commonTransformations = context.CommonTransformations; _connectionProvider = context.ConnectionProvider; }
internal AdoAdapter(IConnectionProvider connectionProvider) : this() { _connectionProvider = connectionProvider; _schema = DatabaseSchema.Get(_connectionProvider, _providerHelper); _relatedFinder = new Lazy<AdoAdapterRelatedFinder>(CreateRelatedFinder); _commandOptimizer = ProviderHelper.GetCustomProvider<CommandOptimizer>(_connectionProvider) ?? new CommandOptimizer(); }
public MigrationInitializer(IConfiguration configuration, IDatabaseProvider databaseProvider, ISchemaProvider schemaProvider, ICommonTransformations commonTransformations, IConnectionProvider connectionProvider) { _configuration = configuration; _commonTransformations = commonTransformations; _databaseProvider = databaseProvider; _schemaProvider = schemaProvider; _connectionProvider = connectionProvider; }
/// <summary> /// Initializes a new instance of the <see cref="AgentUpdater"/> class. /// </summary> /// <param name="connectionProvider">The connection provider.</param> /// <param name="versionProvider">The version provider.</param> /// <param name="updateSource">The update source.</param> /// <param name="agents">The agents.</param> /// <param name="log">The log.</param> public AgentUpdater(IConnectionProvider connectionProvider, IVersionProvider versionProvider, IUpdateSource updateSource, AgentsCollection agents, ILog log) { this.connectionProvider = connectionProvider; this.versionProvider = versionProvider; this.updateSource = updateSource; this.agents = agents; this.log = log; }
public void BulkInsert(IConnectionProvider conn, IEntityCollection newEntities, IEntityDaoFactory daoFactory) { if (newEntities.Count == 0) return; DataTable newRecords = newEntities.ToDataTable(); var bulkCopy = BuildSqlBulkCopy(conn, newEntities.IDbTable.TableName, newRecords); bulkCopy.WriteToServer(newRecords); }
public PayForReservation( IConnectionProvider connectionProvider, RESERVATION selectedReservation, IEventAggregator eventAggregator) { _connectionProvider = connectionProvider; _selectedReservation = selectedReservation; _eventAggregator = eventAggregator; }
private AdoAdapter(IConnectionProvider connectionProvider, AdoAdapterFinder finder, ProviderHelper providerHelper, Lazy<AdoAdapterRelatedFinder> relatedFinder, DatabaseSchema schema) { _connectionProvider = connectionProvider; _finder = finder; _providerHelper = providerHelper; _relatedFinder = relatedFinder; _schema = schema; }
public RemoveFly( IEventAggregator eventAggregator, IConnectionProvider connectionProvider, FLY flyToRemove) { _eventAggregator = eventAggregator; _connectionProvider = connectionProvider; _flyToRemove = flyToRemove; }
public SearchConnections( IConnectionProvider connectionProvider, IEventAggregator eventAggregator, ConnectionsSearchData connectionsSearchData) { _connectionProvider = connectionProvider; _eventAggregator = eventAggregator; _connectionsSearchData = connectionsSearchData; }
public Login( IConnectionProvider connectionProvider, IEventAggregator eventAggregator, LoginData connectionData) { _connectionProvider = connectionProvider; _eventAggregator = eventAggregator; _connectionData = connectionData; }
public RemoveReservation( IConnectionProvider connectionProvider, RESERVATION reservationToRemove, IEventAggregator eventAggregator) { _connectionProvider = connectionProvider; _reservationToRemove = reservationToRemove; _eventAggregator = eventAggregator; }
/// <summary> /// Initializes a new instance of the <see cref="AgentsTracker"/> class. /// </summary> /// <param name="agents">The agents.</param> /// <param name="options">The options.</param> /// <param name="log">The log.</param> /// <param name="providers">The providers.</param> /// <param name="connectionProvider">The connection provider.</param> /// <param name="agentUpdater">The agent updater.</param> public AgentsTracker(AgentsCollection agents, IConnectionsHostOptions options, ILog log, IEnumerable<IAgentsProvider> providers, IConnectionProvider connectionProvider, IAgentUpdater agentUpdater) { this.agents = agents; this.options = options; this.log = log; this.providers = providers; this.connectionProvider = connectionProvider; this.agentUpdater = agentUpdater; }
public StorageAccountService(IStorageAccountRepository storageAccountRepository, IStoragePluginsService storagePluginsService, IStorageAccountSettingsRepository storageAccountSettingsRepository, IConnectionProvider connectionProvider) { _storageAccountRepository = storageAccountRepository; _storagePluginsService = storagePluginsService; _storageAccountSettingsRepository = storageAccountSettingsRepository; _connectionProvider = connectionProvider; }
public ShowFlyDetails( IWindowManager windowManager, FLY selectedFly, Func<FLY, FlyDetailsViewModel> flyDetailsViewModelFactory, IConnectionProvider connectionProvider) { _windowManager = windowManager; _selectedFly = selectedFly; _flyDetailsViewModelFactory = flyDetailsViewModelFactory; _connectionProvider = connectionProvider; }
protected override void Load(ContainerBuilder builder) { // IByteBufferAllocator builder.Register(c => { // TODO - We should probably also use some heuristics to make this determination, like how much memory does the system have. return(this.optimizeForPerformance ? PooledByteBufferAllocator.Default : UnpooledByteBufferAllocator.Default as IByteBufferAllocator); }) .As <IByteBufferAllocator>() .SingleInstance(); builder.Register(c => new ByteBufferConverter(c.Resolve <IByteBufferAllocator>())) .As <IByteBufferConverter>() .SingleInstance(); // MessageAddressConverter builder.Register(c => new MessageAddressConverter(this.conversionConfiguration)) .As <MessageAddressConverter>() .SingleInstance(); // IMessageConverter<IProtocolGatewayMessage> builder.Register(c => new ProtocolGatewayMessageConverter(c.Resolve <MessageAddressConverter>(), c.Resolve <IByteBufferConverter>())) .As <IMessageConverter <IProtocolGatewayMessage> >() .SingleInstance(); // ISettingsProvider builder.Register(c => new MqttSettingsProvider(this.mqttSettingsConfiguration)) .As <ISettingsProvider>() .SingleInstance(); // Task<IMqttConnectionProvider> builder.Register( async c => { var pgMessageConverter = c.Resolve <IMessageConverter <IProtocolGatewayMessage> >(); var byteBufferConverter = c.Resolve <IByteBufferConverter>(); IConnectionProvider connectionProvider = await c.Resolve <Task <IConnectionProvider> >(); IMqttConnectionProvider mqtt = new MqttConnectionProvider(connectionProvider, pgMessageConverter, byteBufferConverter); return(mqtt); }) .As <Task <IMqttConnectionProvider> >() .SingleInstance(); // Task<ISessionStatePersistenceProvider> builder.Register( async c => { if (this.isStoreAndForwardEnabled) { IEntityStore <string, SessionState> entityStore = new StoreProvider(c.Resolve <IDbStoreProvider>()).GetEntityStore <string, SessionState>(Core.Constants.SessionStorePartitionKey); IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >(); return(new SessionStateStoragePersistenceProvider(edgeHub, entityStore) as ISessionStatePersistenceProvider); } else { IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >(); return(new SessionStatePersistenceProvider(edgeHub) as ISessionStatePersistenceProvider); } }) .As <Task <ISessionStatePersistenceProvider> >() .SingleInstance(); // MqttProtocolHead builder.Register( async c => { var settingsProvider = c.Resolve <ISettingsProvider>(); var websocketListenerRegistry = c.Resolve <IWebSocketListenerRegistry>(); var byteBufferAllocator = c.Resolve <IByteBufferAllocator>(); var mqttConnectionProviderTask = c.Resolve <Task <IMqttConnectionProvider> >(); var sessionStatePersistenceProviderTask = c.Resolve <Task <ISessionStatePersistenceProvider> >(); var authenticatorProviderTask = c.Resolve <Task <IAuthenticator> >(); IClientCredentialsFactory clientCredentialsProvider = c.Resolve <IClientCredentialsFactory>(); IMqttConnectionProvider mqttConnectionProvider = await mqttConnectionProviderTask; ISessionStatePersistenceProvider sessionStatePersistenceProvider = await sessionStatePersistenceProviderTask; IAuthenticator authenticator = await authenticatorProviderTask; return(new MqttProtocolHead( settingsProvider, this.tlsCertificate, mqttConnectionProvider, authenticator, clientCredentialsProvider, sessionStatePersistenceProvider, websocketListenerRegistry, byteBufferAllocator, this.clientCertAuthAllowed)); }) .As <Task <MqttProtocolHead> >() .SingleInstance(); base.Load(builder); }
/// <summary> /// Initializes a new instance of the <see cref="WhatIfExecuter"/> class. /// </summary> /// <param name="serializer">Json serializer</param> /// <param name="reader">File reader</param> /// <param name="connectionProvider">Connection provider</param> /// <param name="logger">Logger</param> public WhatIfExecuter(IJsonSerializer serializer, IFileReader reader, IConnectionProvider connectionProvider, ILogger logger) : base(serializer, reader, connectionProvider, logger) { }
/// <summary> /// 修改账号信息 /// </summary> /// <param name="AccountModel"></param> /// <returns></returns> public static bool EditAccount(USER_SHARE_ACCOUNTMODEL AccountModel, USER_SHARE_LOGMODEL log) { bool blSuccess = false; StringBuilder strSql = new StringBuilder(); strSql.Append("update USER_SHARE_ACCOUNT set "); strSql.Append("ACCOUNTNAME=:ACCOUNTNAME,"); strSql.Append("COMPANYID=:COMPANYID,"); strSql.Append("ACCOUNTPWD=:ACCOUNTPWD,"); strSql.Append("ORIGNALPWD=:ORIGNALPWD,"); strSql.Append("REALNAME=:REALNAME,"); strSql.Append("EMAIL=:EMAIL,"); strSql.Append("ROLEIDS=:ROLEIDS,"); strSql.Append("LINKPHONE=:LINKPHONE,"); strSql.Append("CREATEDATE=:CREATEDATE,"); strSql.Append("CREATORID=:CREATORID,"); strSql.Append("ISADMIN=:ISADMIN,"); strSql.Append("STATUS=:STATUS"); strSql.Append(" where ACCOUNTID=:ACCOUNTID "); ParamList param = new ParamList(); param["ACCOUNTID"] = AccountModel.ACCOUNTID; param["ACCOUNTNAME"] = AccountModel.ACCOUNTNAME; param["COMPANYID"] = AccountModel.COMPANYID; param["ACCOUNTPWD"] = AccountModel.ACCOUNTPWD; param["ORIGNALPWD"] = AccountModel.ORIGNALPWD; param["REALNAME"] = AccountModel.REALNAME; param["EMAIL"] = AccountModel.EMAIL; param["ROLEIDS"] = AccountModel.ROLEIDS; param["LINKPHONE"] = AccountModel.LINKPHONE; param["CREATEDATE"] = AccountModel.CREATEDATE; param["CREATORID"] = AccountModel.CREATORID; param["ISADMIN"] = AccountModel.ISADMIN; param["STATUS"] = AccountModel.STATUS; IConnectionProvider connection = ConnectionProviderBuilder.CreateConnectionProvider(); try { using (connection) { connection.BeginTranscation(); //修改账号信息 connection.ExecuteNonQuery(strSql.ToString(), param); param.Clear(); //操作日志 strSql = new StringBuilder(); strSql.Append("insert into USER_SHARE_LOG("); strSql.Append("LOGID,OPERATETYPE,OPERATORID,PROJECTID,COMPANYID,OPERATECONTENT,OPERATEDATE)"); strSql.Append(" values ("); strSql.Append(":LOGID,:OPERATETYPE,:OPERATORID,:PROJECTID,:COMPANYID,:OPERATECONTENT,:OPERATEDATE)"); param["LOGID"] = log.LOGID; param["OPERATETYPE"] = log.OPERATETYPE; param["OPERATORID"] = log.OPERATORID; param["PROJECTID"] = log.PROJECTID; param["COMPANYID"] = log.COMPANYID; param["OPERATECONTENT"] = log.OPERATECONTENT; param["OPERATEDATE"] = log.OPERATEDATE; connection.ExecuteNonQuery(strSql.ToString(), param); connection.CommitTranscation(); blSuccess = true; } } catch (Exception ex) { connection.RollbackTranscation(); LogHelper.WriteErr("修改账号信息时发生错误,账号名称:" + AccountModel.ACCOUNTNAME, ex); } return(blSuccess); }
public StorageAccountRepository(IConnectionProvider connectionProvider) { _connectionProvider = connectionProvider; }
internal static bool TryLoadAssemblyUsingAttribute(string connectionString, string providerName, out IConnectionProvider connectionProvider) { var attributes = LoadAssemblyAttributes(); if (attributes.Count == 0) { connectionProvider = null; return(false); } if (!string.IsNullOrWhiteSpace(providerName)) { attributes = attributes.Where(a => a.IsForProviderName(providerName)).ToList(); } if (attributes.Count == 0) { connectionProvider = null; return(false); } return(LoadUsingAssemblyAttribute(connectionString, attributes, out connectionProvider)); }
public MicrOrmTransaction(IConnectionProvider connectionProvider) : base(connectionProvider) { Transaction = Connection.BeginTransaction(); }
public static Task <bool> BroadcastAsync <T>(this IConnectionProvider connectionProvider, T update) { return(connectionProvider.ForAllConnectionsAsync(x => x.SendAsync(update))); }
public UserProcessor(IConnectionProvider connectionProvider) { this.connectionProvider = connectionProvider; }
public static async Task <IStorageAccount> GetStorageAccountAsync(this IStorageAccountProvider provider, IConnectionProvider connectionProvider, CancellationToken cancellationToken, INameResolver nameResolver = null) { return(await provider.GetStorageAccountAsync(connectionProvider.Connection, cancellationToken, nameResolver)); }
public IStatementExecutor UseConnectionProvider( IConnectionProvider connectionProvider) { this.connectionProvider = connectionProvider; return(this); }
public async Task InvokeAsync(HttpContext context, ILogger <RequestLogMiddleware> logger, IRequestLogRepository requestLogRepository, IConnectionProvider connectionProvider) { logger.LogTrace("Entered InvokeAsync"); var sw = new Stopwatch(); sw.Start(); await _next(context); sw.Stop(); var requestLog = new RequestLog(); requestLog.Endpoint = context.Request.PathBase + context.Request.Path; requestLog.IpAddress = context.Connection.RemoteIpAddress; requestLog.ResponseMs = (int)sw.ElapsedMilliseconds; requestLog.HttpMethod = context.Request.Method; requestLog.QueryString = context.Request.QueryString.Value; requestLog.StatusCode = context.Response.StatusCode; var userIdClaim = context.User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid); if (userIdClaim != null) { requestLog.UserId = int.Parse(userIdClaim.Value); } using (var conn = await connectionProvider.GetOpenConnectionAsync()) { await requestLogRepository.InsertRequestLog(requestLog, conn); } }
public StatementExecutorBase(ISqlLogger logger, IConnectionProvider connectionProvider) { this.logger = logger; this.connectionProvider = connectionProvider; }
public IContentService CreateFtpService(IConnectionProvider connectionProvider) { return(new FtpService(utilityFactory.CreateRequestHandler(), connectionProvider)); }
public ClientConnectionsHandler(IConnectionProvider connectionProvider, AmqpConnection amqpConnection) { this.connectionProvider = Preconditions.CheckNotNull(connectionProvider, nameof(connectionProvider)); this.amqpConnection = Preconditions.CheckNotNull(amqpConnection, nameof(amqpConnection)); }
public ResourceRepository() { _connectionProvider = new ConnectionProvider(); }
public FormRepository(UserManager <DapperIdentityUser> userManager, IConnectionProvider connection, IUnitOfWork unitOfWork) { _userManager = userManager; _transaction = unitOfWork; _connectionProvider = connection; }
public T GetCustomProvider <T>(IConnectionProvider connectionProvider) { return((T)_customProviderCache.GetOrAdd(typeof(T), t => GetCustomProviderExport <T>(connectionProvider))); }
public RepositoryFactory(IConnectionProvider connectionProvider, IMapper mapper) { _connectionProvider = connectionProvider; _mapper = mapper; }
public UserService(IConnectionProvider connectionProvider, ILogger <UserService> logger) { this.connectionProvider = connectionProvider; this.logger = logger; }
public AuthService(ConfigContext config, AuthenticationStateProvider authenticationStateProvider) { _connectionProvider = new SqlConnectionProvider(config.McpDb); _authenticationStateProvider = authenticationStateProvider; }
public SystemInteractionService(IHostApplicationLifetime appLifetime, IConnectionProvider connectionProvider, ICustomCommandConfigurationService customCommandConfigurationService) { _appLifetime = appLifetime ?? throw new ArgumentNullException(nameof(appLifetime)); _connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider)); _customCommandConfigurationService = customCommandConfigurationService ?? throw new ArgumentNullException(nameof(customCommandConfigurationService)); }
public ColumnRepository(ILogger <ColumnRepository> logger, IConnectionProvider connectionProvider) : base(logger, connectionProvider) { }
/// <summary> /// 获取分页数据 /// </summary> /// <typeparam name="TFirst"></typeparam> /// <typeparam name="TSecond"></typeparam> /// <typeparam name="TReturn">dto</typeparam> /// <param name="map">委托函数</param> /// <param name="criteriaModel">查询数据Model</param> /// <param name="splitOn">表示查询的SQL语句中根据哪个字段进行分割</param> /// <returns></returns> public async Task <BasePagedListModel <TReturn> > GetPageDataAsync <TFirst, TSecond, TReturn>(IConnectionProvider connectionProvider, Func <TFirst, TSecond, TReturn> map, PageCriteriaModel criteriaModel, string splitOn = "Id") { using (var conn = connectionProvider.CreateConn()) { DynamicParameters parameters = new DynamicParameters(); parameters.Add("TableName", criteriaModel.TableName); parameters.Add("PrimaryKey", criteriaModel.PrimaryKey); parameters.Add("Fields", criteriaModel.Fields); parameters.Add("Condition", criteriaModel.Condition); parameters.Add("PageIndex", criteriaModel.PageIndex); parameters.Add("PageSize", criteriaModel.PageSize); parameters.Add("Sort", criteriaModel.Sort); parameters.Add("RecordCount", dbType: DbType.Int32, direction: ParameterDirection.Output); BasePagedListModel <TReturn> listModel = new BasePagedListModel <TReturn>() { Data = await conn.QueryAsync("sp_get_PageData", map, parameters, null, true, splitOn, null, commandType : CommandType.StoredProcedure), Total = parameters.Get <int>("RecordCount") }; return(listModel); } }
public SuppliedConnectionProviderConnectionHelper(IConnectionProvider provider) { this.provider = provider; }
public T GetCustomProvider <T>(IConnectionProvider connectionProvider) { return((T)_customProviderCache.GetOrAdd(typeof(T), t => GetCustomProviderExport <T>(connectionProvider.GetType().Assembly) ?? GetCustomProviderServiceProvider(connectionProvider as IServiceProvider, t))); }
/// <summary> /// 更新一条数据 /// </summary> public static bool UpdateCompanyFun(USER_SHARE_COMPANYFUNMODEL model, USER_SHARE_LOGMODEL log) { bool blResult = false; StringBuilder strSql = new StringBuilder(); strSql.Append("update USER_SHARE_COMPANYFUN set "); strSql.Append("FMID=:FMID,"); strSql.Append("PROJECTID=:PROJECTID,"); strSql.Append("COMPANYID=:COMPANYID,"); strSql.Append("CFNAME=:CFNAME,"); strSql.Append("CFANOTHERNAME=:CFANOTHERNAME,"); strSql.Append("CFPAGEURL=:CFPAGEURL,"); strSql.Append("CFPARENTID=:CFPARENTID,"); strSql.Append("CFSORTNUM=:CFSORTNUM,"); strSql.Append("CFSTEP=:CFSTEP,"); strSql.Append("CFISLAST=:CFISLAST,"); strSql.Append("CFDESC=:CFDESC,"); strSql.Append("CFSTATUS=:CFSTATUS"); strSql.Append(" where CFID=:CFID "); ParamList param = new ParamList(); param["CFID"] = model.CFID; param["FMID"] = model.FMID; param["PROJECTID"] = model.PROJECTID; param["COMPANYID"] = model.COMPANYID; param["CFNAME"] = model.CFNAME; param["CFANOTHERNAME"] = model.CFANOTHERNAME; param["CFPAGEURL"] = model.CFPAGEURL; param["CFPARENTID"] = model.CFPARENTID; param["CFSORTNUM"] = model.CFSORTNUM; param["CFSTEP"] = model.CFSTEP; param["CFISLAST"] = model.CFISLAST; param["CFDESC"] = model.CFDESC; param["CFSTATUS"] = model.CFSTATUS; IConnectionProvider connection = ConnectionProviderBuilder.CreateConnectionProvider(); try { using (connection) { connection.BeginTranscation(); //增加项目信息 connection.ExecuteNonQuery(strSql.ToString(), param); param.Clear(); //操作日志 strSql = new StringBuilder(); strSql.Append("insert into USER_SHARE_LOG("); strSql.Append("LOGID,OPERATETYPE,OPERATORID,PROJECTID,COMPANYID,OPERATECONTENT,OPERATEDATE)"); strSql.Append(" values ("); strSql.Append(":LOGID,:OPERATETYPE,:OPERATORID,:PROJECTID,:COMPANYID,:OPERATECONTENT,:OPERATEDATE)"); param["LOGID"] = log.LOGID; param["OPERATETYPE"] = log.OPERATETYPE; param["OPERATORID"] = log.OPERATORID; param["PROJECTID"] = log.PROJECTID; param["COMPANYID"] = log.COMPANYID; param["OPERATECONTENT"] = log.OPERATECONTENT; param["OPERATEDATE"] = log.OPERATEDATE; connection.ExecuteNonQuery(strSql.ToString(), param); connection.CommitTranscation(); blResult = true; } } catch (Exception ex) { connection.RollbackTranscation(); LogHelper.WriteErr("修改公司功能菜单时出现异常,Id:" + model.FMID, ex); } return(blResult); }
/// <summary> /// 新增账号信息 /// </summary> /// <param name="AccountModel"></param> /// <returns></returns> public static bool AddAccount(USER_SHARE_ACCOUNTMODEL AccountModel, USER_SHARE_LOGMODEL log) { bool blSuccess = false; StringBuilder strSql = new StringBuilder(); strSql.Append("insert into USER_SHARE_ACCOUNT("); strSql.Append("ACCOUNTID,ACCOUNTNAME,COMPANYID,ACCOUNTPWD,ORIGNALPWD,REALNAME,EMAIL,ROLEIDS,LINKPHONE,CREATEDATE,CREATORID,ISADMIN,STATUS)"); strSql.Append(" values ("); strSql.Append(":ACCOUNTID,:ACCOUNTNAME,:COMPANYID,:ACCOUNTPWD,:ORIGNALPWD,:REALNAME,:EMAIL,:ROLEIDS,:LINKPHONE,:CREATEDATE,:CREATORID,:ISADMIN,:STATUS)"); ParamList param = new ParamList(); param["ACCOUNTID"] = AccountModel.ACCOUNTID; param["ACCOUNTNAME"] = AccountModel.ACCOUNTNAME; param["COMPANYID"] = AccountModel.COMPANYID; param["ACCOUNTPWD"] = AccountModel.ACCOUNTPWD; param["ORIGNALPWD"] = AccountModel.ORIGNALPWD; param["REALNAME"] = AccountModel.REALNAME; param["EMAIL"] = AccountModel.EMAIL; param["ROLEIDS"] = AccountModel.ROLEIDS; param["LINKPHONE"] = AccountModel.LINKPHONE; param["CREATEDATE"] = AccountModel.CREATEDATE; param["CREATORID"] = AccountModel.CREATORID; param["ISADMIN"] = AccountModel.ISADMIN; param["STATUS"] = AccountModel.STATUS; IConnectionProvider connection = ConnectionProviderBuilder.CreateConnectionProvider(); try { using (connection) { connection.BeginTranscation(); //增加账号信息 connection.ExecuteNonQuery(strSql.ToString(), param); param.Clear(); if (AccountModel.ISADMIN == 1)//初始账号时更新公司关联信息表 { string strUpSql = string.Format("UPDATE USER_SHARE_COMPANYRELATE SET ADMINID={0} WHERE COMPANYCODE={1} ", AccountModel.ACCOUNTID, AccountModel.COMPANYID); connection.ExecuteNonQuery(strUpSql); } //操作日志 strSql = new StringBuilder(); strSql.Append("insert into USER_SHARE_LOG("); strSql.Append("LOGID,OPERATETYPE,OPERATORID,PROJECTID,COMPANYID,OPERATECONTENT,OPERATEDATE)"); strSql.Append(" values ("); strSql.Append(":LOGID,:OPERATETYPE,:OPERATORID,:PROJECTID,:COMPANYID,:OPERATECONTENT,:OPERATEDATE)"); param["LOGID"] = log.LOGID; param["OPERATETYPE"] = log.OPERATETYPE; param["OPERATORID"] = log.OPERATORID; param["PROJECTID"] = log.PROJECTID; param["COMPANYID"] = log.COMPANYID; param["OPERATECONTENT"] = log.OPERATECONTENT; param["OPERATEDATE"] = log.OPERATEDATE; connection.ExecuteNonQuery(strSql.ToString(), param); connection.CommitTranscation(); blSuccess = true; } } catch (Exception ex) { connection.RollbackTranscation(); LogHelper.WriteErr("新增账号信息时发生错误,账号名称:" + AccountModel.ACCOUNTNAME, ex); } return(blSuccess); }
public IRepository <TEntity> UseConnectionProvider(IConnectionProvider connectionProvider) { this.statementFactory.UseConnectionProvider(connectionProvider); return(this); }
public TenantDBSet(IConnectionProvider connectionProvider, IMetadataProvider metadataProvider, TableSchema <T> tableSchema) : base(connectionProvider, metadataProvider, tableSchema) { tenantIdColumn = metadataProvider.GetColumnName(Constants.TenantIdFieldName, tableSchema.TableName); }
public ISqlStatement <TResult> UseConnectionProvider(IConnectionProvider connectionProvider) { this.StatementExecutor.UseConnectionProvider(connectionProvider); return(this); }