private void MaskButton_OnClick(object sender, RoutedEventArgs e)
        {
            bool noWorkload = false;
            string functionName = dVM.FunctionName;
            StringBuilder loggingString = new StringBuilder();
            int ctable = dVM.CurrentTable.TableId;
            string ctablename = dVM.CurrentTable.Name;
            string ccolumn = dVM.CurrentColumn.Name;
            int ccolumnid = dVM.CurrentColumn.ColumnId;
            string type = dVM.db.Tables[ctable].Columns[ccolumnid].Type;
            Trace.TraceInformation("a"+type);
            Random rand = new Random();
            // string x =(dVM.db.Tables[ctable].Data.Tables[0].Columns[ccolumn].ToString());
            //Trace.TraceInformation("god"+x.ToString());
            if (dVM.WorkloadLoaded)
            {
                if (conditions.Count == 0)
                {
                    noWorkload = true;
                }
            }
            if (dVM.MaskTechnique)
            {
                if (!dVM.IsKey(ctable, ccolumn))
                {
                    loggingString.Append("Table name: " + ctablename);
                    loggingString.Append(Environment.NewLine);
                    loggingString.Append("Column name: " + ccolumn);
                    loggingString.Append(Environment.NewLine);
                    loggingString.Append("Original\t\tMasked");
                    loggingString.Append(Environment.NewLine);
                    DataTable origVals = dVM.db.Tables[ctable].Data.Tables[0].Copy();
                    for (int i = 0; i < dVM.db.Tables[ctable].Data.Tables[0].Rows.Count; i++)
                    {
                        bool shouldMask = false;
                        bool shouldMask1 = true;
                        if (type.Equals("int"))
                        {
                            int firstParam = 0;
                            int secParam = 0;
                            if (!FirstParameter.Text.Equals(""))
                            {
                                firstParam = Int32.Parse(FirstParameter.Text);
                            }
                            if (!SecondParameter.Text.Equals(""))
                            {
                                secParam = Int32.Parse(SecondParameter.Text);
                            }
                            var o = origVals.Rows[i][ccolumn].ToString();
                            int m = 0;
                            var x = Int32.Parse(dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn].ToString());
                            Trace.TraceInformation("Original: " + x.ToString());
                            loggingString.Append(o + "\t\t");
                            if (dVM.WorkloadLoaded)
                            {
                                foreach (var c in conditions)
                                {
                                    if (ctablename == c.TableName && ccolumn == c.ColumnName)
                                    {
                                        if (!mask.Operator(c.Operator, x, Int32.Parse(c.Value)))
                                        {
                                            if (functionName.Equals("Shuffle"))
                                            {
                                                int len = dVM.db.Tables[ctable].Data.Tables[0].Rows.Count;
                                                int y = i + (int)(rand.NextDouble() * (len - i));
                                                int tmp =Int32.Parse(dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn].ToString());
                                                m = Int32.Parse(dVM.db.Tables[ctable].Data.Tables[0].Rows[y][ccolumn].ToString());
                                                dVM.db.Tables[ctable].Data.Tables[0].Rows[y][ccolumn] = tmp;
                                            }
                                            else
                                            {
                                                m = MaskInt(x, firstParam, secParam, functionName);
                                            }

                                        }
                                        else
                                        {
                                            m = x;
                                            shouldMask1 = false;
                                        }
                                    }
                                    else
                                    {
                                        shouldMask = true;
                                    }
                                }
                            }
                            else
                            {
                                noWorkload = true;
                            }
                            if (noWorkload)
                            {
                                if (functionName.Equals("Shuffle"))
                                {
                                    int len = dVM.db.Tables[ctable].Data.Tables[0].Rows.Count;
                                    int y = i + (int)(rand.NextDouble() * (len - i));
                                    int tmp = Int32.Parse(dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn].ToString());
                                    m = Int32.Parse(dVM.db.Tables[ctable].Data.Tables[0].Rows[y][ccolumn].ToString());
                                    dVM.db.Tables[ctable].Data.Tables[0].Rows[y][ccolumn] = tmp;
                                }
                                else
                                {
                                    m = MaskInt(x, firstParam, secParam, functionName);
                                }
                            }
                            if (shouldMask1 && shouldMask)
                            {
                                if (functionName.Equals("Shuffle"))
                                {
                                    int len = dVM.db.Tables[ctable].Data.Tables[0].Rows.Count;
                                    int y = i + (int)(rand.NextDouble() * (len - i));
                                    int tmp = Int32.Parse(dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn].ToString());
                                    m = Int32.Parse(dVM.db.Tables[ctable].Data.Tables[0].Rows[y][ccolumn].ToString());
                                    dVM.db.Tables[ctable].Data.Tables[0].Rows[y][ccolumn] = tmp;
                                }
                                else
                                {
                                    m = MaskInt(x, firstParam, secParam, functionName);
                                }
                            }
                            Trace.TraceInformation("Masked: " +
                                                   (dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn] = m).ToString());
                            loggingString.Append(m);
                            loggingString.Append(Environment.NewLine);

                            //Table.BuildInsertCommand(dVM.db.Tables[ctable].Data,dVM.db.Tables[ctable].Name);
                            //Table.DisableConstrains();
                            //Table.DeleteData(dVM.db.Tables[ctable].Name);
                            //Table.InsertData(dVM.db.Tables[ctable].Data,dVM.db.Tables[ctable].Name);
                            //Table.EnableConstrains();

                            //Trace.TraceInformation(m.ToString());
                            Trace.Flush();
                        }
                        //todo: dodělat pro dalši datove typy a upravit varchar
                        else if (type.Equals("varchar") || type.Equals("nvarchar") || type.Equals("varchar2") || type.Equals("text"))
                        {
                            int firstParam = Int32.Parse(FirstParameter.Text);
                            int secParam = Int32.Parse(SecondParameter.Text);
                            string x = dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn].ToString();
                            Trace.TraceInformation("Orig: " + x);
                            loggingString.Append(x + "\t\t");
                            string m = "";
                            if (dVM.WorkloadLoaded)
                            {
                                foreach (var c in conditions)
                                {
                                    if (ctablename == c.TableName && ccolumn == c.ColumnName)
                                    {
                                        if (!mask.StrOperator(c.Operator, x, c.Value))
                                        {

                                            m = MaskString(x, firstParam, secParam, functionName);
                                        }
                                        else
                                        {
                                            m = x;
                                            shouldMask1 = false;
                                        }
                                    }
                                    else
                                    {
                                        shouldMask = true;
                                    }

                                }
                            }
                            else
                            {
                                noWorkload = true;
                            }
                            if (noWorkload)
                                m = MaskString(x, firstParam, secParam, functionName);
                            if (shouldMask1 && shouldMask)
                            {
                                m = MaskString(x, firstParam, secParam, functionName);
                            }
                            dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn] = m;
                            Trace.TraceInformation("Masked: " + m);
                            loggingString.Append(m);
                            loggingString.Append(Environment.NewLine);
                        }
                        else if (type.Equals("date"))
                        {
                            //int firstParam = Int32.Parse(FirstParameter.Text);
                            //int secParam = Int32.Parse(SecondParameter.Text);
                            DateTime x = (DateTime) dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn];
                            Trace.TraceInformation("Orig: " + x);
                            DateTime m = new DateTime();
                            if (dVM.WorkloadLoaded)
                            {
                                foreach (var c in conditions)
                                {
                                    if (ctablename == c.TableName && ccolumn == c.ColumnName)
                                    {
                                        string tmp = Query.DateConvert(c.Value);
                                        DateTime myDate = DateTime.Parse(tmp);
                                        if (!mask.DateOperator(c.Operator, x, myDate))
                                        {
                                            m = MaskDate(x, functionName);
                                        }
                                        else
                                        {
                                            m = x;
                                            shouldMask1 = false;
                                        }
                                    }
                                    else
                                    {
                                        shouldMask = true;
                                    }

                                }
                            }
                            else
                            {
                                noWorkload = true;
                            }
                            if (noWorkload)
                                m = MaskDate(x, functionName);
                            if (shouldMask1 && shouldMask)
                            {
                                m = MaskDate(x, functionName);
                            }
                            dVM.db.Tables[ctable].Data.Tables[0].Rows[i][ccolumn] = m;
                            Trace.TraceInformation("Masked: " + m);
                        }
                    }
                    VievValues.Visibility = Visibility.Visible;
                    loggingString.Append(Environment.NewLine);
                    loggingString.Append("--------------------------");
                    loggingString.Append(Environment.NewLine);
                    LogValues(loggingString.ToString());
                    dVM.MaskTechnique = false;
                    InfoLabel.Content = "Data in column " + ccolumn + " in table "+ ctablename + " was masked";
                    MasksComboBox.SelectedItem = null;
                }
                else
                    InfoLabel.Content = "Primary keys, Foreign keys and Unique columns cannot be masked!";
            }
            else
                InfoLabel.Content = "Mask technique was not selected";

            Trace.Flush();
        }