public AccessSchemaProvider(IConnectionProvider connectionProvider)
		{
			if (connectionProvider == null)
				throw new ArgumentNullException("connectionProvider");

			_connectionProvider = connectionProvider;
		}
Example #2
0
        /// <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));
 }
Example #6
0
 /// <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);
 }
Example #7
0
 private static bool EnsureOpenConnection(IConnectionProvider conn)
 {
     bool connIsOpennedLocally = !conn.IsOpen;
     if (connIsOpennedLocally)
         conn.OpenConnection();
     return connIsOpennedLocally;
 }
Example #8
0
 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;
 }
Example #11
0
 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);
 }
Example #14
0
 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;
		}
Example #18
0
 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;
 }
Example #20
0
 /// <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;
 }
Example #23
0
 private AdoAdapter(IConnectionProvider connectionProvider, AdoAdapterFinder finder, ProviderHelper providerHelper,
     Lazy<AdoAdapterRelatedFinder> relatedFinder, DatabaseSchema schema)
 {
     _connectionProvider = connectionProvider;
     _finder = finder;
     _providerHelper = providerHelper;
     _relatedFinder = relatedFinder;
     _schema = schema;
 }
Example #24
0
 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;
 }
Example #26
0
 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;
 }
Example #28
0
 /// <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;
 }
Example #31
0
        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)
 {
 }
Example #33
0
        /// <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;
 }
Example #35
0
        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));
        }
Example #36
0
 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)));
 }
Example #38
0
 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);
 }
Example #41
0
        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;
 }
Example #43
0
 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));
 }
Example #45
0
 public ResourceRepository()
 {
     _connectionProvider = new ConnectionProvider();
 }
Example #46
0
 public FormRepository(UserManager <DapperIdentityUser> userManager, IConnectionProvider connection, IUnitOfWork unitOfWork)
 {
     _userManager        = userManager;
     _transaction        = unitOfWork;
     _connectionProvider = connection;
 }
Example #47
0
 public T GetCustomProvider <T>(IConnectionProvider connectionProvider)
 {
     return((T)_customProviderCache.GetOrAdd(typeof(T), t => GetCustomProviderExport <T>(connectionProvider)));
 }
Example #48
0
 public RepositoryFactory(IConnectionProvider connectionProvider, IMapper mapper)
 {
     _connectionProvider = connectionProvider;
     _mapper             = mapper;
 }
Example #49
0
 public UserService(IConnectionProvider connectionProvider, ILogger <UserService> logger)
 {
     this.connectionProvider = connectionProvider;
     this.logger             = logger;
 }
Example #50
0
 public AuthService(ConfigContext config, AuthenticationStateProvider authenticationStateProvider)
 {
     _connectionProvider          = new SqlConnectionProvider(config.McpDb);
     _authenticationStateProvider = authenticationStateProvider;
 }
Example #51
0
 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));
 }
Example #52
0
 public ColumnRepository(ILogger <ColumnRepository> logger,
                         IConnectionProvider connectionProvider)
     : base(logger, connectionProvider)
 {
 }
Example #53
0
 /// <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;
 }
Example #55
0
 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);
        }
Example #57
0
        /// <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);
        }
Example #58
0
 public IRepository <TEntity> UseConnectionProvider(IConnectionProvider connectionProvider)
 {
     this.statementFactory.UseConnectionProvider(connectionProvider);
     return(this);
 }
Example #59
0
 public TenantDBSet(IConnectionProvider connectionProvider,
                    IMetadataProvider metadataProvider,
                    TableSchema <T> tableSchema) : base(connectionProvider, metadataProvider, tableSchema)
 {
     tenantIdColumn = metadataProvider.GetColumnName(Constants.TenantIdFieldName, tableSchema.TableName);
 }
Example #60
0
 public ISqlStatement <TResult> UseConnectionProvider(IConnectionProvider connectionProvider)
 {
     this.StatementExecutor.UseConnectionProvider(connectionProvider);
     return(this);
 }