/// <summary>
 /// Initialize connection factory
 /// </summary>
 public virtual void InitConnectionFactory()
 {
     var connectionFactory = new SqlConnectionFactory();
     //TODO fix compilation warning (below)
     #pragma warning disable 0618
     Database.DefaultConnectionFactory = connectionFactory;
 }
 /// <summary>
 ///     Inicializa las conexiones
 /// </summary>
 public virtual void InitConnectionFactory()
 {
     var connectionFactory = new SqlConnectionFactory();
     #pragma warning disable 0618
     Database.DefaultConnectionFactory = connectionFactory;
     //@todo http://www.entityframeworktutorial.net/EntityFramework6/code-based-configuration.aspx
 }
        /// <summary>
        /// Initialize connection factory
        /// </summary>
        public virtual void InitConnectionFactory()
        {
            var connectionFactory = new SqlConnectionFactory();

            #pragma warning disable 618
            Database.DefaultConnectionFactory = connectionFactory;
            #pragma warning restore 618
        }
        public virtual void InitConnectionFactory()
        {
            var connectionFactory = new SqlConnectionFactory();
            //TODO fix compilation warning (below)
            #pragma warning disable 0618
            Database.DefaultConnectionFactory = connectionFactory;

            File.WriteAllText(@"D:\bbbbbb.txt", "Duoc chay ne");
        }
Example #5
0
        public void SetsEnlistFalseOnConnectionStringIfEnlistTransactionFalse()
        {
            // Arrange
            var sut = new SqlConnectionFactory(DatabaseFixture.LogEventsConnectionString, false, false,
                                               _sqlConnectionStringBuilderWrapperMock.Object, _azureManagedServiceAuthenticatorMock.Object);

            // Act
            using (var connection = sut.Create())
            { }

            // Assert
            _sqlConnectionStringBuilderWrapperMock.VerifySet(c => c.ConnectionString = DatabaseFixture.LogEventsConnectionString);
            _sqlConnectionStringBuilderWrapperMock.VerifySet(c => c.Enlist           = false);
        }
Example #6
0
        public void CreateWithUseAzureManagedIdentitiesFalseDoesNotCallAzureManagedServiceAuthenticator()
        {
            // Arrange
            var sut = new SqlConnectionFactory(DatabaseFixture.LogEventsConnectionString, true, false,
                                               _sqlConnectionStringBuilderWrapperMock.Object, _azureManagedServiceAuthenticatorMock.Object);

            // Act
            using (var connection = sut.Create())
            {
            }

            // Assert
            _azureManagedServiceAuthenticatorMock.Verify(a => a.GetAuthenticationToken(), Times.Never);
        }
Example #7
0
        public IEnumerable <ContactEmail> GetContactEmails(int contactId)
        {
            using (var connection = SqlConnectionFactory.GetConnection(configuration))
            {
                const string query = @"
SELECT 
    contact_email_id AS Id,
    email as Email
FROM contact_email
WHERE contact_id = @ContactId";

                return(connection.Query <ContactEmail>(query, new { ContactId = contactId }));
            }
        }
Example #8
0
        public void DeleteUserGroups(string ids)
        {
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                string[] IDsarray = ids.Split(',');
                foreach (string id in IDsarray)
                {
                    UserGroupDataLayer.GetInstance().DeleteGroupPermission(connection, Int32.Parse(id));
                    UserGroupDataLayer.GetInstance().DeleteUserGroup(connection, id);
                }
            }
        }
Example #9
0
        public void CategoryRepositor_LoadDataFromDbThroughRepository()
        {
            using (var db = SqlConnectionFactory.GetSqlConnection()) {
                db.DeleteAll <Category>();
                db.InsertWithChildren(new Category {
                    Name = "Foooo"
                });
            }

            var repository = new CategoryRepository(new CategoryDataAccess());

            Assert.IsTrue(repository.Data.Any());
            Assert.AreEqual("Foooo", repository.Data[0].Name);
        }
Example #10
0
        public ActionMessage Delete(int id, string _userID)
        {
            ActionMessage ret = new ActionMessage();

            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                try
                {
                    //delete Items Table
                    List <AuditEmployeeInfo> currentItems = AuditDataLayer.GetInstance().GetAuditEmployeesById(connection, id.ToString());
                    if (currentItems.Count > 0)
                    {
                        string autoIds = "";
                        foreach (var item in currentItems)
                        {
                            autoIds = autoIds + item.AutoID + ',';
                        }
                        autoIds = autoIds.Remove(autoIds.Length - 1);
                        //    AuditDataLayer.GetInstance().DeleteAuditEmployees(connection, autoIds);
                    }

                    //delete attach files and DB of attach files
                    DocumentService.GetInstance().DeleteDocumentByFeature(TableFile.Audit.ToString(), id);


                    //delete commet
                    CommentSeachCriteria _criteria = new CommentSeachCriteria();
                    _criteria.TableName = TableFile.Audit.ToString();
                    _criteria.PreferId  = id.ToString();
                    CommentDataLayer.GetInstance().DeleteComment(connection, _criteria);

                    //delete Process

                    List <string> quoteID = AuditDataLayer.GetInstance().GetQuoteByAuditIds(connection, id.ToString());
                    QuoteService.GetInstance().deleteProcess(connection, "Audit", String.Join(", ", quoteID.ToArray()), _userID);
                    AuditDataLayer.GetInstance().Delete(connection, id);
                    ret.isSuccess = true;
                }
                catch (Exception ex)
                {
                    ret.isSuccess     = false;
                    ret.err.msgCode   = "Internal Error";
                    ret.err.msgString = ex.ToString();
                }
            }
            return(ret);
        }
Example #11
0
        public async Task <SaveResult> Save(Material Material)
        {
            SaveResult saveRlt = new SaveResult();

            saveRlt.UniqueKey = Material.ItemCode;//回传接收方的主键
            using (IDbConnection conn = SqlConnectionFactory.CreateSqlConnection())
            {
                conn.Open();
                IDbTransaction dbTransaction = conn.BeginTransaction();
                try
                {
                    string insertSql = @"INSERT INTO T_Materials (ItemCode,ItemName,VatGourpSa,VatGourpPu,InitialCost,RealCost,SalesPrice,InvntItem,Consignment,Vendor,OMSGroupNum,CreateDate,UpdateDate)
                                            VALUES (@ItemCode,@ItemName,@VatGourpSa,@VatGourpPu,@InitialCost,@RealCost,@SalesPrice,@InvntItem,@Consignment,@Vendor,@OMSGroupNum,@CreateDate,@UpdateDate)";
                    await conn.ExecuteScalarAsync(insertSql,
                                                  new
                    {
                        ItemCode    = Material.ItemCode,
                        ItemName    = Material.ItemName,
                        VatGourpSa  = Material.VatGourpSa,
                        VatGourpPu  = Material.VatGourpPu,
                        InitialCost = Material.InitialCost,
                        RealCost    = Material.RealCost,
                        SalesPrice  = Material.SalesPrice,
                        InvntItem   = Material.InvntItem,
                        Consignment = Material.Consignment,
                        Vendor      = Material.Vendor,
                        CreateDate  = DateTime.Now,
                        UpdateDate  = DateTime.Now,
                        OMSGroupNum = Material.OMSGroupNum
                    }, dbTransaction);

                    saveRlt.ReturnUniqueKey = Material.ItemCode;//回传保存订单的主键
                    dbTransaction.Commit();
                    saveRlt.Code = 0;
                }
                catch (Exception ex)
                {
                    dbTransaction.Rollback();
                    saveRlt.Code    = 1;
                    saveRlt.Message = ex.Message;
                    throw ex;
                }
                finally
                {
                    conn.Close();
                }
                return(saveRlt);
            }
        }
Example #12
0
        public int getNewId()
        {
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                List <CustomerInfo> ListCustomer = CustomerDataLayer.GetInstance().GetAllCustomer(connection);
                CustomerInfo        lastCustomer = ListCustomer.Last();
                if (lastCustomer != null)
                {
                    return(lastCustomer.CustomerID + 1);
                }
                return(1);
            }
        }
        static async Task SendMessage(TableBasedQueue tableBasedQueue, SqlConnectionFactory sqlConnectionFactory)
        {
            using (var scope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
            {
                using (var connection = await sqlConnectionFactory.OpenNewConnection())
                    using (var tx = connection.BeginTransaction())
                    {
                        var message = new OutgoingMessage(Guid.NewGuid().ToString(), new Dictionary <string, string>(), new byte[0]);
                        await tableBasedQueue.Send(message, TimeSpan.MaxValue, connection, tx);

                        tx.Commit();
                        scope.Complete();
                    }
            }
        }
        async Task PrepareAsync(CancellationToken cancellationToken = default)
        {
            var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, new QueueSchemaAndCatalogOptions());
            var tableCache    = new TableBasedQueueCache(addressParser, true);

            var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";

            sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);

            await CreateOutputQueueIfNecessary(addressParser, sqlConnectionFactory, cancellationToken);

            await PurgeOutputQueue(addressParser, cancellationToken);

            dispatcher = new MessageDispatcher(addressParser, new NoOpMulticastToUnicastConverter(), tableCache, null, sqlConnectionFactory);
        }
Example #15
0
        //private void btnOkEmail_Click(object sender, EventArgs e)
        //{
        //	using (SQLiteConnection connection = SqlConnectionFactory.GetSQLiteConnectionWithLock())
        //	{
        //		DateTime dt = MainActivity.GetLocalTime();
        //		connection.Insert(new EmailAddresses()
        //		{
        //			Date = dt,
        //			IsValid = true,
        //			EmailType = true,
        //			Email = txtNewEmail.Text
        //		});
        //		EmailAddresses ea = connection.Table<EmailAddresses>().Last();
        //		lblOutEmail.Text = $"OK => {ea.ToString()}";
        //	}
        //}

        private void btnOk_Click(object sender, EventArgs e)
        {
            using (SQLiteConnection connection = SqlConnectionFactory.GetSQLiteConnectionWithLock())
            {
                DateTime dt = MainActivity.GetLocalTime();
                connection.Insert(new FromPassword()
                {
                    Date    = dt,
                    IsValid = true,
                    Pass    = pass1.Text,
                });
                FromPassword ea = connection.Table <FromPassword>().Last();
                lblOut.Text = $"OK => {ea.ToString()}";
            }
        }
Example #16
0
        public AnalyzerInfo getAnalyzer(int _ID)
        {
            AnalyzerInfo         record        = new AnalyzerInfo();
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                record = AnalyzerDataLayer.GetInstance().getAnalyzer(connection, _ID);
                if (record == null)
                {
                    return(null);
                }
                return(record);
            }
        }
Example #17
0
        public int getNewId()
        {
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                List <ProposalTypeInfo> ListProposalType = ProposalTypeDataLayer.GetInstance().GetAllProposalType(connection);
                ProposalTypeInfo        lastProposalType = ListProposalType.Last();
                if (lastProposalType != null)
                {
                    return(lastProposalType.TypeID + 1);
                }
                return(1);
            }
        }
Example #18
0
        public int getNewId()
        {
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                List <DepartmentInfo> ListDepartment = DepartmentDataLayer.GetInstance().GetAllDepartment(connection);
                DepartmentInfo        lastDepartment = ListDepartment.Last();
                if (lastDepartment != null)
                {
                    return(lastDepartment.DepartmentID + 1);
                }
                return(1);
            }
        }
Example #19
0
        public async Task <string[]> GetAllAsync()
        {
            using (var connection = await SqlConnectionFactory.CreateAndOpenAsync(_builder.CloneForMaster().ConnectionString))
                using (var command = new SqlCommand(Commands.Database_Get_All, connection))
                {
                    var result = new List <string>();
                    var reader = await command.ExecuteReaderAsync();

                    while (await reader.ReadAsync())
                    {
                        result.Add(reader.GetString(0));
                    }
                    return(result.OrderBy(s => s).ToArray());
                }
        }
Example #20
0
 public List <CommentInfo> getComment(CommentSeachCriteria _criteria)
 {
     if (!string.IsNullOrEmpty(_criteria.TableName) && !string.IsNullOrEmpty(_criteria.PreferId))
     {
         SqlConnectionFactory sqlConnection = new SqlConnectionFactory();
         using (SqlConnection connection = sqlConnection.GetConnection())
         {
             List <CommentInfo> ListComment = CommentDataLayer.GetInstance().getComment(connection, _criteria);
             return(ListComment);
         }
     }
     else
     {
         return(null);
     }
 }
Example #21
0
        public AnalyzerInfo GetAnalyzerByCode(string code)
        {
            AnalyzerInfo         record        = new AnalyzerInfo();
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                record = AnalyzerDataLayer.GetInstance().GetAnalyzerByCode(connection, code);
                if (record == null)
                {
                    return(null);
                }

                return(record);
            }
        }
Example #22
0
        public List <AnalyzerInfo> GetAnalyzerByDate(AnalyzerSeachCriteria date)
        {
            List <AnalyzerInfo>  record        = new List <AnalyzerInfo>();
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                record = AnalyzerDataLayer.GetInstance().GetAnalyzerByDate(connection, date);
                if (record == null)
                {
                    return(null);
                }

                return(record);
            }
        }
Example #23
0
        public void SqlConnectionFactory_handles_provider_factory_returning_null_connection()
        {
            var mockProviderFactory = new Mock <DbProviderFactory>();

            mockProviderFactory.Setup(m => m.CreateConnection()).Returns <DbConnection>(null);

            var factory = new SqlConnectionFactory
            {
                ProviderFactory = name => mockProviderFactory.Object
            };

            var connection = factory.CreateConnection("FakeDatabaseName");

            Assert.Equal(typeof(SqlConnection), connection.GetType());
            Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
        }
Example #24
0
        public void TestFileOutput()
        {
            var facade = Helper.CreateFacade(ConnectionString);
            IDataManagerFactory dataManagerFactory = new FakeDataManagerFactory();
            var connectionFactory  = new SqlConnectionFactory(ConnectionString);
            var dataManager        = dataManagerFactory.CreateDataManager(connectionFactory.CreateConnection(), null);
            var securityRepository = facade.RepositoryManager.ClaimSecurityRepository(dataManager);

            var fileManager = new TradingTargetsFileManager();
            var targetings  = fileManager.GetFileContent(securityRepository, dataManager);

            using (StreamWriter sw = new StreamWriter(String.Format(@"C:\temp\AshmoreEMM_Models - as of {0:yyyyMMdd}-{0:HHmmss}.CSV", DateTime.Now)))
            {
                sw.Write(targetings);
            }
        }
        static async Task ReceiveWithLongHandling(TableBasedQueue tableBasedQueue, SqlConnectionFactory sqlConnectionFactory)
        {
            using (var scope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
            {
                using (var connection = await sqlConnectionFactory.OpenNewConnection())
                    using (var tx = connection.BeginTransaction())
                    {
                        await tableBasedQueue.TryReceive(connection, tx);

                        await Task.Delay(TimeSpan.FromSeconds(ReceiveDelayInSeconds));

                        tx.Commit();
                        scope.Complete();
                    }
            }
        }
Example #26
0
 public List <ItemInfo> GetItemsByCondition(string name, string code)
 {
     try
     {
         SqlConnectionFactory sqlConnection = new SqlConnectionFactory();
         using (SqlConnection connection = sqlConnection.GetConnection())
         {
             List <ItemInfo> ret = ItemsDataLayer.GetInstance().GetItemsByCondition(connection, name, code, "VT");
             return(ret);
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #27
0
        public async Task GetAsync_ShouldPerformCorrectly(
            SqlConnectionFactory sqlConnectionFactory)
        {
            // Arrange
            var goalId = new Guid("ca41679d-ffb0-4899-a357-9f4de75d278a");
            var sut    = new GoalQuery(sqlConnectionFactory);

            // Act
            var result = await sut.GetAsync(goalId);

            // Asserts
            result.Should().NotBeNull();
            result.Id.Should().Be(new Guid("ca41679d-ffb0-4899-a357-9f4de75d278a"));
            result.Title.Should().Be("Check E-mails");
            result.Count.Should().Be(50);
        }
Example #28
0
 public List <EmployeeInfo> GetEmployeesByCondition(string name)
 {
     try
     {
         SqlConnectionFactory sqlConnection = new SqlConnectionFactory();
         using (SqlConnection connection = sqlConnection.GetConnection())
         {
             List <EmployeeInfo> ret = EmployeeDataLayer.GetInstance().GetEmployeeByCondition(connection, name);
             return(ret);
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #29
0
        public ActionMessage CreateQuoteWithMutilProposal(QuoteCreateRequest QuoteObj, string _userI)
        {
            ActionMessage        ret           = new ActionMessage();
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                try
                {
                    int quoteId = 0;

                    quoteId = QuoteDataLayer.GetInstance().InsertQuoteWithOutDetails(connection, _userI);
                    int i = 0;
                    foreach (int customerID in QuoteObj.CustomerList)
                    {
                        if (QuoteObj.CustomerList.Length == 1)
                        {
                            QuoteDataLayer.GetInstance().InsertQuoteCustomer(connection, quoteId, customerID, true);
                        }
                        else
                        {
                            if (i == 0)
                            {
                                QuoteDataLayer.GetInstance().InsertQuoteCustomer(connection, quoteId, customerID, true);
                            }
                            else
                            {
                                QuoteDataLayer.GetInstance().InsertQuoteCustomer(connection, quoteId, customerID, false);
                            }
                        }
                        i++;
                    }
                    foreach (int proposalId in QuoteObj.ProposalList)
                    {
                        QuoteDataLayer.GetInstance().InsertQuoteProposal(connection, quoteId, proposalId);
                    }
                    ret.isSuccess = true;
                }
                catch (Exception ex)
                {
                    ret.isSuccess     = false;
                    ret.err.msgCode   = "Internal Error";
                    ret.err.msgString = ex.Message;
                }
            }
            return(ret);
        }
Example #30
0
        public ContractInfo GetContractByCode(string code, string _userID)
        {
            ContractInfo         record        = new ContractInfo();
            SqlConnectionFactory sqlConnection = new SqlConnectionFactory();

            using (SqlConnection connection = sqlConnection.GetConnection())
            {
                record = ContractDataLayer.GetInstance().GeContractByCode(connection, code, _userID);
                if (record == null)
                {
                    return(null);
                }

                record.Items = new List <ItemInfo>();
                record.Items = QuoteDataLayer.GetInstance().GetQuoteItems(connection, record.QuoteID);

                QuoteInfo quote = QuoteDataLayer.GetInstance().getQuote(connection, record.QuoteID, _userID);
                if (quote.TotalCost > 30000000)
                {
                    record.DeliveryReceiptType = 2;
                }
                else
                {
                    record.DeliveryReceiptType = 1;
                }
                //Get document
                DocumentSeachCriteria documentCriteria = new DocumentSeachCriteria();
                documentCriteria.TableName = TableFile.Contract.ToString();
                documentCriteria.PreferId  = record.QuoteID.ToString();
                record.ListDocument        = DocumentService.GetInstance().GetDocument(documentCriteria);

                //get Comment
                CommentSeachCriteria commentCriteria = new CommentSeachCriteria();
                commentCriteria.TableName = TableFile.Contract.ToString();
                commentCriteria.PreferId  = record.QuoteID.ToString();
                record.ListComment        = CommentService.GetInstance().getComment(commentCriteria);
                foreach (var item in record.ListComment)
                {
                    DocumentSeachCriteria documentCriteria2 = new DocumentSeachCriteria();
                    documentCriteria2.TableName = TableFile.Comment.ToString();
                    documentCriteria2.PreferId  = item.AutoID.ToString();
                    item.ListDocument           = DocumentService.GetInstance().GetDocument(documentCriteria2);
                }

                return(record);
            }
        }
Example #31
0
        public void ConfigureServices(IServiceCollection services)
        {
            var dataAccessOptionsSection = Configuration.GetSection(nameof(DataAccessOptions));
            var dataAccessOptions        = dataAccessOptionsSection.Get <DataAccessOptions>();

            services.Configure <DataAccessOptions>(dataAccessOptionsSection);

            var rabbitMqOptionsSection = Configuration.GetSection(nameof(RabbitMqOptions));
            var rabbitMqOptions        = rabbitMqOptionsSection.Get <RabbitMqOptions>();

            services.Configure <RabbitMqOptions>(rabbitMqOptionsSection);

            var rabbitMqConnectionString =
                $"amqp://{rabbitMqOptions.User}:{rabbitMqOptions.Password}@{rabbitMqOptions.Host}:{rabbitMqOptions.Port.ToString()}";

            services.AddRebus(configure => configure
                              .Transport(x =>
            {
                x.UseRabbitMq(rabbitMqConnectionString, rabbitMqOptions.InputQueueName);
            })
                              .Outbox(c => c.UseSqlServer(() =>
            {
                var dbConnection = (DbConnection)SqlConnectionFactory.GetOpenConnection(dataAccessOptions.ConnectionString);
                return(Task.FromResult(dbConnection));
            }, "dbo.OutboxMessages"), options =>
            {
                options.RunMessagesProcessor  = true;
                options.MaxMessagesToRetrieve = 5;
            })
                              .Routing(r => r.TypeBased()));

            services.AddMvc();
            services.AddOptions();

            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo
                {
                    Version     = "v1",
                    Title       = "My API",
                    Description = ""
                });
            });

            services.AddSingleton <IOrdersService, OrdersService>();
            services.AddTransient <IHandleMessages <OrderCreated>, OrderCreatedMessageHandler>();
        }
        public async Task cannot_connect_to_sql_database_and_return_record_returns_unhealthy_status()
        {
            //arrange
            var connection    = DotNetEnv.Env.GetString("test");
            var loggerFactory = new LoggerFactory();

            _sqlConnectionFactory = new SqlConnectionFactory(connection, loggerFactory.CreateLogger <SqlConnectionFactory>());
            var logger = loggerFactory.CreateLogger <SqlConnectionHealthCheck>();

            _classUnderTest = new SqlConnectionHealthCheck(_sqlConnectionFactory, logger);
            //act
            var result = await _classUnderTest.CheckAsync(CancellationToken.None).ConfigureAwait(false);

            //assert
            result.Should().NotBeNull();
            result.CheckStatus.Should().Be(CheckStatus.Unhealthy);
        }
        public async Task SetUp()
        {
            var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, null);

            var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");

            if (string.IsNullOrEmpty(connectionString))
            {
                connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
            }

            sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);

            await CreateQueueIfNotExists(addressParser, sqlConnectionFactory);

            queue = new TableBasedQueue(addressParser.Parse(QueueTableName).QualifiedTableName, QueueTableName, true);
        }
        static async Task ResetQueue(QueueAddressTranslator addressTranslator, SqlConnectionFactory sqlConnectionFactory)
        {
            var queueCreator  = new QueueCreator(sqlConnectionFactory, addressTranslator);
            var queueBindings = new QueueBindings();

            queueBindings.BindReceiving(QueueTableName);

            using (var connection = await sqlConnectionFactory.OpenNewConnection().ConfigureAwait(false))
            {
                using (var comm = connection.CreateCommand())
                {
                    comm.CommandText = $"IF OBJECT_ID('{QueueTableName}', 'U') IS NOT NULL DROP TABLE {QueueTableName}";
                    comm.ExecuteNonQuery();
                }
            }
            await queueCreator.CreateQueueIfNecessary(queueBindings, "").ConfigureAwait(false);
        }
        public static void AppInitialize()
        {
            ConnectionStringSettings connectionString = ConfigurationManager.ConnectionStrings["SqlServerVirtualPathProvider"];
            ISqlConnectionFactory factory = new SqlConnectionFactory(connectionString);
            if (HostingEnvironment.IsHosted)
            {
                HostingEnvironment.RegisterVirtualPathProvider(new SqlServerVirtualPathProvider(factory));
            }

            //test for proper connection
            try
            {
                using (IDbConnection conn = factory.CreateConnection())
                {
                    conn.Close();
                }
            }
            catch (SqlException)
            {
                throw new ArgumentException("connection string missing or invalid");
            }

            EnsureDatabaseSchemaIsValid();
        }
Example #36
0
 public MetaFieldsController(SqlConnectionFactory f)
 {
     _repository = new MetaFieldRepository(f, new MetaFieldValidator());
 }
        public void SqlConnectionFactory_handles_no_provider_factory_found()
        {
            var factory = new SqlConnectionFactory
                              {
                                  ProviderFactory = name => null
                              };

            var connection = factory.CreateConnection("FakeDatabaseName");

            Assert.Equal(typeof(SqlConnection), connection.GetType());
            Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
        }
        public void SqlConnectionFactory_handles_provider_factory_returning_null_connection()
        {
            var mockProviderFactory = new Mock<DbProviderFactory>();
            mockProviderFactory.Setup(m => m.CreateConnection()).Returns<DbConnection>(null);

            var factory = new SqlConnectionFactory
                              {
                                  ProviderFactory = name => mockProviderFactory.Object
                              };

            var connection = factory.CreateConnection("FakeDatabaseName");

            Assert.Equal(typeof(SqlConnection), connection.GetType());
            Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
        }
        public void SqlConnectionFactory_default_db_provider_factory_creates_sql_connection()
        {
            var factory = new SqlConnectionFactory();

            var providerFactory = factory.ProviderFactory("System.Data.SqlClient");

            Assert.Equal(typeof(SqlClientFactory), providerFactory.GetType());
        }
        public void SqlConnectionFactory_uses_db_provider_factory()
        {
            var mockProviderFactory = new Mock<DbProviderFactory>();
            var mockConnection = new Mock<DbConnection>();
            mockConnection.SetupProperty(c => c.ConnectionString);
            mockProviderFactory.Setup(m => m.CreateConnection()).Returns(mockConnection.Object);

            var factory = new SqlConnectionFactory
                              {
                                  ProviderFactory = name => mockProviderFactory.Object
                              };

            var connection = factory.CreateConnection("FakeDatabaseName");

            Assert.Same(mockConnection.Object, connection);
            Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
        }
        public void SqlConnectionFactory_uses_changed_base_connection_string_when_creating_connection_string()
        {
            var factory = new SqlConnectionFactory("Data Source=190.190.200.100,1433");

            Assert.Equal("Data Source=190.190.200.100,1433", factory.BaseConnectionString);

            var connection = factory.CreateConnection("FakeDatabaseName");

            Assert.True(connection.ConnectionString.Contains("Data Source=190.190.200.100,1433"));
            Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
        }
        public void SqlConnectionFactory_replaces_any_initial_catalog_set_in_the_base_connection()
        {
            var factory = new SqlConnectionFactory(
                @"Data Source=.\SQLEXPRESS; Integrated Security=True; Initial Catalog=TheManWithTheStick");

            var connection = factory.CreateConnection("FakeDatabaseName");

            Assert.False(connection.ConnectionString.Contains("Initial Catalog=TheManWithTheStick"));
            Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
        }
        public void SqlConnectionFactory_throws_if_given_MDF_filename()
        {
            var factory = new SqlConnectionFactory();

            Assert.Equal(
                Strings.SqlConnectionFactory_MdfNotSupported("FakeDatabaseName.mdf"),
                Assert.Throws<NotSupportedException>(() => factory.CreateConnection("FakeDatabaseName.mdf")).Message);
        }
        public void SqlConnectionFactory_uses_database_name_as_initial_catalog()
        {
            var factory = new SqlConnectionFactory();

            var connection = factory.CreateConnection("FakeDatabaseName");

            Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
            AssertConnectionStringHasDefaultParts(connection.ConnectionString);
        }
        public void SqlConnectionFactory_creates_SqlConnection()
        {
            var factory = new SqlConnectionFactory();

            var connection = factory.CreateConnection("FakeDatabaseName");

            Assert.IsType<SqlConnection>(connection);
        }
 public void SqlConnectionFactory_throws_when_a_bad_base_connection_string_is_used()
 {
     var factory = new SqlConnectionFactory("You Wouldnt Let It Lie=True");
     Assert.Throws<ArgumentException>(() => factory.CreateConnection("FakeDatabaseName")).ValidateMessage(
         typeof(SqlConnection).Assembly(), "ADP_KeywordNotSupported", null, "you wouldnt let it lie");
 }
 /// <summary>
 /// Initialize connection factory
 /// </summary>
 public virtual void InitConnectionFactory()
 {
     var connectionFactory = new SqlConnectionFactory();
     Database.DefaultConnectionFactory = connectionFactory;
 }