private static bool ExecuteSqlScript(ConnectionProvider provider, string scriptFile)
        {
            if (!File.Exists(scriptFile))
            {
                stdio.ErrorFormat("no input file found : {0}", scriptFile);
                return false;
            }

            stdio.WriteLine("Execute {0}", scriptFile);
            var script = new SqlScript(provider, scriptFile);
            script.Reported += (sender, e) =>
            {
                // stdio.WriteLine("processed: {0}>{1}", e.Value1, e.Value2);
            };

            bool hasError = false;
            script.Error += (sender, e) =>
            {
                hasError = true;
                stdio.ErrorFormat("line:{0}, {1}, SQL:{2}", e.Line, e.Exception.Message, e.Command);
            };

            Func<bool> stopOnError = () =>
            {
                return !stdio.YesOrNo("are you sure to contune (yes/no)?:");
            };

            script.Execute(stopOnError);
            stdio.WriteLine("completed to run {0}", scriptFile);

            return !hasError;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Slot"/> class.
 /// </summary>
 /// <param name="address">The address.</param>
 /// <param name="connection">The connection.</param>
 /// <param name="id">The id.</param>
 public Slot(uint address, ConnectionProvider connection, InventoryID id)
 {
     this.address = address;
     this.id = id;
     this.memory = connection.Memory;
     this.connection = connection;
 }

 public RiaDbConnection(ConnectionProvider provider)
 {
     this.Provider = provider;
     this.ConnectionString = Provider.ConnectionString;
     this.DataSource = Provider.DataSource;
     this.database = Provider.InitialCatalog;
 }

        public SqlEditor(Configuration cfg, ConnectionProvider provider, FileLink link)
        {
            InitializeComponent(cfg);

            this.cfg = cfg;
            this.provider = provider;

            textBox.Document.Blocks.Clear();
            if (link != null)
            {
                this.link = link;
                string text = link.ReadAllText();
                textBox.Document.Blocks.Add(new Paragraph(new Run(text)));
            }
            else
            {
                this.link = FileLink.CreateLink(untitled);
            }
            UpdateTitle();

            tabControl.SelectionChanged += TabControl_SelectionChanged;
            textBox.SelectionChanged += TextBox_SelectionChanged;
            textBox.TextChanged += TextBox_TextChanged;
            textBox.Focus();
        }

        public static RemoveTextPacket Create(ConnectionProvider connection, string TextName)
        {
            PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.RemoveText);
            p.AddString(TextName);

            return new RemoveTextPacket(connection, p.GetPacket());
        }

        public static InjectDisplayPacket Create(ConnectionProvider connection, bool Injected)
        {
            PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.InjectDisplayText);
            p.AddByte(Convert.ToByte(Injected));

            return new InjectDisplayPacket(connection, p.GetPacket());
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="MessageProvider"/> class.
 /// </summary>
 /// <param name="connection">The connection.</param>
 public MessageProvider(ConnectionProvider connection)
 {
     Connection = connection;
     Server = new Actions.Messages.Server(connection);
     System = new Actions.Messages.System(connection);
     Screen = new Actions.Messages.Screen(connection);
 }

        public static RemoveCreatureTextPacket Create(ConnectionProvider connection, int CreatureID, string CreatureName)
        {
            PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.RemoveCreatureText);
            p.AddLong(CreatureID);
            p.AddString(CreatureName);

            return new RemoveCreatureTextPacket(connection, p.GetPacket());
        }

 /// <summary>
 /// Binds the packet.
 /// </summary>
 /// <param name="encryptedData">The encrypted data.</param>
 /// <param name="connection">The connection.</param>
 /// <param name="cripto">The cripto.</param>
 /// <returns></returns>
 public static Packet BindPacket(byte[] data, ConnectionProvider connection)
 {
     return new Packet {
         Data = data,
         ConnectionSource = connection,
         InterceptedDate = DateTime.Now,
     };
 }

        public SqlScript(ConnectionProvider provider, string scriptFile)
        {
            this.provider = provider;
            this.scriptFile = scriptFile;

            if (!File.Exists(scriptFile))
                throw new FileNotFoundException("cannot find file", scriptFile);
        }

        public XmlDbConnection(ConnectionProvider provider)
        {
            this.Provider = provider;
            this.ConnectionString = Provider.ConnectionString;
            this.DataSource = Provider.DataSource;
            this.database = Provider.InitialCatalog;

            this.FileLink = FileLink.CreateLink(provider.DataSource, provider.UserId, provider.Password);
        }

        public static UpdateCreatureTextPacket Create(ConnectionProvider connection, int CreatureID, string CreatureName, Location TextLoc, string NewText)
        {
            PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.UpdateCreatureText);
            p.AddLong(CreatureID);
            p.AddString(CreatureName);
            p.AddShort(TextLoc.X);
            p.AddShort(TextLoc.Y);
            p.AddString(NewText);

            return new UpdateCreatureTextPacket(connection, p.GetPacket());
        }

		protected virtual bool IsSupported (ConnectionProvider provider)
		{
			if (HasFlag (InstrumentationConnectionFlags.RequireMonoClient) && !SupportsMonoExtensions (provider))
				return false;
			if (HasFlag (InstrumentationConnectionFlags.RequireEcDhe) && !SupportsEcDhe (provider))
				return false;
			if ((provider.Flags & ConnectionProviderFlags.SupportsTls12) == 0)
				return false;

			return true;
		}

 public ActionResult Edit(int id, ConnectionProvider connectionProvider)
 {
     try
     {
         _dbConnectionProviderRepository.Update(connectionProvider);
         return RedirectToAction("Index");
     }
     catch
     {
         return View(connectionProvider);
     }
 }

 public void Update(string name, string value, int id)
 {
     using (var client = new HttpClient(_messageHandler))
     {
         client.BaseAddress = new Uri(_baseAddress);
         client.DefaultRequestHeaders.Accept.Clear();
         client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
         var connectionProvider = new ConnectionProvider(id, name, value);
         var response = client.PutAsync(UrlBase, connectionProvider, new JsonMediaTypeFormatter()).Result;
         response.EnsureSuccessStatusCode();
     }
 }

 public ActionResult Create(ConnectionProvider connectionProvider)
 {
     try
     {
         _dbConnectionProviderRepository.Insert(connectionProvider);
         return RedirectToAction("Index");
     }
     catch
     {
         return View(connectionProvider);
     }
 }

        public DbProvider(string script, ConnectionProvider provider)
        {
            this.script = script;
            this.provider = provider;

            this.DbConnection = this.provider.NewDbConnection;
            this.DbCommand = NewDbCommand();

            if (this.script.Contains(" "))  //Stored Procedure Name does not contain a space letter
                this.DbCommand.CommandType = CommandType.Text;
            else
                this.DbCommand.CommandType = CommandType.StoredProcedure;
        }

        public void DeleteRedemption(int nTransactionID, int qtyOfItemToRestoreAfterDelete)
        {
            TblRewardsTransaction rewardTrans = new TblRewardsTransaction();
            rewardTrans.NTransactionID = nTransactionID;
            rewardTrans.SelectOne();

            if (rewardTrans.NTypeID != 2 || (Convert.ToDateTime(rewardTrans.DtDate.Value).Date != DateTime.Now.Date && ACMSLogic.User.RightsLevelID != 9000))
                throw new Exception("You have no right to delete this record. It is not a redemption or the redemption date is before today. ");

            string itemCode = rewardTrans.StrReferenceNo.IsNull ? "" : rewardTrans.StrReferenceNo.Value;

            //TblProductInventory productInvent = new TblProductInventory();
            //productInvent.StrProductCode = itemCode;
            //productInvent.SelectOne();

            //productInvent.NQuantity = ACMS.Convert.ToInt32(productInvent.NQuantity) + qtyOfItemToRestoreAfterDelete;

            ACMSDAL.ConnectionProvider connProvider = new ConnectionProvider();

            try
            {

                rewardTrans.MainConnectionProvider = connProvider;
                //productInvent.MainConnectionProvider = connProvider;

                connProvider.OpenConnection();
                connProvider.BeginTransaction("DeleteRedemption");
                rewardTrans.Delete();
                //productInvent.Update();

                connProvider.CommitTransaction();
            }
            catch (Exception)
            {
                connProvider.RollbackTransaction("DeleteRedemption");
                throw;
            }
            finally
            {
                if (connProvider.CurrentTransaction != null)
                    connProvider.CurrentTransaction.Dispose();

                if (connProvider.DBConnection != null)
                {
                    if (connProvider.DBConnection.State == ConnectionState.Open)
                        connProvider.DBConnection.Close();
                }
                rewardTrans.MainConnactionIsCreatedLocal = true;
                //productInvent.MainConnactionIsCreatedLocal = true;
            }
        }

        public void FirstThrowsSocketUsesSecondAndWorksTwice()
        {

            var d1 = new DummyConnectionFactoryWrapper(new SocketException(123));
            var d2 = new DummyConnectionFactoryWrapper(true);

            var cp = new ConnectionProvider(d2, d1);
           
            var connection = cp.GetConnection();
            Assert.NotNull(connection);
            var connection2 = cp.GetConnection();
            Assert.NotNull(connection2);

        }

        public void FirstConnectionNoyOpenUsesSecondAndWorksTwice()
        {

            var d1 = new DummyConnectionFactoryWrapper(false);
            var d2 = new DummyConnectionFactoryWrapper(true);

            var cp = new ConnectionProvider(d2, d1);

            var connection = cp.GetConnection();
            Assert.NotNull(connection);
            var connection2 = cp.GetConnection();
            Assert.NotNull(connection2);
            Assert.Equal(1, d1.NumberOfTimesCalled);
        }