Beispiel #1
0
        private async void LaboratoryDataTableRowDeleting(object sender, DataRowChangeEventArgs e)
        {
            if (this.DeleteHandled)
            {
                this.DeleteHandled = false;
                return;
            }

            var result = await MainWindowHelper.DeleteRowAsync
                         (
                LaboratoryBookName,
                LaboratoryBookPermission,
                e.Row
                         );

            if (result)
            {
                e.Row.AcceptChanges();
                TaskBarIcon.ShowBalloonTip
                (
                    "Row action",
                    $"Row was successfully deleted from {LaboratoryBookName} database",
                    BalloonIcon.Info
                );
                await MainWindowHelper.UpdateStatistics(LaboratoryBookName, User);
            }
            else
            {
                e.Row.RejectChanges();
            }
        }
Beispiel #2
0
        private async void LaboratoryDataTableRowChanged(object sender, DataRowChangeEventArgs e)
        {
            bool result = false;

            var laboratoryBookName       = this.LaboratoryBookName;
            var laboratoryBookPermission = this.LaboratoryBookPermission;
            var row = e.Row;
            var dgLaboratoryBook = this.DgLaboratoryBook;

            var columnList = new List <string>();

            foreach (var column in dgLaboratoryBook.Columns)
            {
                if ((string)(column.Header) == "sampleID")
                {
                    continue;
                }

                var str = column.Header.ToString();
                columnList.Add(str);
            }

            if (e.Action == DataRowAction.Add)
            {
                result = await Task.Run(() =>
                {
                    return(MainWindowHelper.AddRow(laboratoryBookName, laboratoryBookPermission, row, dgLaboratoryBook, User));
                });

                TaskBarIcon.ShowBalloonTip
                (
                    "Row action",
                    $"Row was successfully added to {LaboratoryBookName} database",
                    BalloonIcon.Info
                );
            }
            if (e.Action == DataRowAction.Change)
            {
                result = await Task.Run(() =>
                {
                    return(MainWindowHelper.ChangeRow(laboratoryBookName, laboratoryBookPermission, row, columnList));
                });
            }


            if (result)
            {
                await MainWindowHelper.UpdateStatistics(LaboratoryBookName, User);

                e.Row.AcceptChanges();
            }
            else
            {
                e.Row.RejectChanges();
            }
        }
Beispiel #3
0
        //set up preferences for timer which send update notifications
        public void SetUpAndStartTimer()
        {
            _timerCheckUpdated.Interval = 3000;
            _timerCheckUpdated.Elapsed += async(obj, args) =>
            {
                string[] result = await MainWindowHelper.CheckUpdatesAsync(LaboratoryBookName);

                if (_lastUpdated != DateTime.Parse(result[1]) & (User.UserName != result[0].ToString()))
                {
                    TaskBarIcon.ShowBalloonTip
                    (
                        "Book updates",
                        $"Database was changed by {result[0]} ({result[1]})",
                        BalloonIcon.Info
                    );
                }
                _lastUpdated = DateTime.Parse(result[1]);
            };
            _timerCheckUpdated.Start();
        }
Beispiel #4
0
        private async void DgLaboratoryBook_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
        {
            var laboratoryBookName = this.LaboratoryBookName;

            var header = e.Column.Header.ToString();
            var row    = e.Row.Item as DataRowView;

            object changingValue = null;

            if (e.EditingElement is ComboBox comboBox)
            {
                changingValue = comboBox.SelectedValue;
            }
            else if (e.EditingElement is TextBox textBox)
            {
                changingValue = textBox.Text;
            }
            var sampeId = row[0];

            bool changeCellResult = false;

            try
            {
                changeCellResult = await Task.Run(() =>
                {
                    return(MainWindowHelper.ChangeCell(laboratoryBookName, header, changingValue, sampeId));
                });

                await MainWindowHelper.UpdateStatistics(LaboratoryBookName, User);
            }
            catch (Exception exception)
            {
                MessageBox.Show
                (
                    exception.Message,
                    "Cell change error",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error
                );
            }
        }
Beispiel #5
0
        //set pre defined lists
        private async Task SetLists()
        {
            var laboratoryBookName = this.LaboratoryBookName;

            var RegimesTask = Task.Run(() =>
            {
                return(MainWindowHelper.SetColumnList(LaboratoryBookName, ColumnToGet.Regime));
            });
            var OperatorsTask = Task.Run(() =>
            {
                return(MainWindowHelper.SetColumnList(LaboratoryBookName, ColumnToGet.Operator));
            });
            var MaterialsTask = Task.Run(() =>
            {
                return(MainWindowHelper.SetColumnList(LaboratoryBookName, ColumnToGet.Material));
            });
            var SubstratesTask = Task.Run(() =>
            {
                return(MainWindowHelper.SetColumnList(LaboratoryBookName, ColumnToGet.Substrate));
            });
            var PermissionIDsTask = Task.Run(() =>
            {
                return(MainWindowHelper.SetColumnList(LaboratoryBookName, ColumnToGet.PermissionID));
            });

            var Tasks = new List <Task <ObservableCollection <object> > > {
                RegimesTask,
                OperatorsTask,
                MaterialsTask,
                SubstratesTask,
                PermissionIDsTask
            };

            while (Tasks.Any())
            {
                var compleatedTask = await Task.WhenAny(Tasks.ToArray());

                if (compleatedTask == RegimesTask)
                {
                    this.Regimes = compleatedTask.Result;
                    Tasks.Remove(compleatedTask);
                }
                else if (compleatedTask == OperatorsTask)
                {
                    this.Operators = compleatedTask.Result;
                    Tasks.Remove(compleatedTask);
                }
                else if (compleatedTask == MaterialsTask)
                {
                    this.Materials = compleatedTask.Result;
                    Tasks.Remove(compleatedTask);
                }
                else if (compleatedTask == SubstratesTask)
                {
                    this.Substrates = compleatedTask.Result;
                    Tasks.Remove(compleatedTask);
                }
                else
                {
                    this.PermssionIDs = compleatedTask.Result;
                    Tasks.Remove(compleatedTask);
                }
            }
        }