void SaveOutputStreamDevice(OutputStreamDevice outputStreamDevice, bool isNew, string originalAcronym)
        {
            SystemMessages sm;
            try
            {
                string result = CommonFunctions.SaveOutputStreamDevice(null, outputStreamDevice, isNew, originalAcronym);
                sm = new SystemMessages(new Message() { UserMessage = result, SystemMessage = string.Empty, UserMessageType = MessageType.Success },
                        ButtonType.OkOnly);
                sm.Owner = Window.GetWindow(this);
                sm.WindowStartupLocation = WindowStartupLocation.CenterOwner;
                sm.ShowPopup();
                GetOutputStreamDeviceList();
                //ClearForm();

                //make this newly added or updated item as default selected. So user can click initialize right away.
                ListBoxOutputStreamDeviceList.SelectedItem = ((List<OutputStreamDevice>)ListBoxOutputStreamDeviceList.ItemsSource).Find(c => c.Acronym == outputStreamDevice.Acronym);

            }
            catch (Exception ex)
            {
                CommonFunctions.LogException(null, "WPF.SaveOutputStreamDevice", ex);
                sm = new SystemMessages(new Message() { UserMessage = "Failed to Save Output Stream Device Information", SystemMessage = ex.Message, UserMessageType = MessageType.Error },
                        ButtonType.OkOnly);
                sm.Owner = Window.GetWindow(this);
                sm.WindowStartupLocation = WindowStartupLocation.CenterOwner;
                sm.ShowPopup();
            }
        }
        void ListBoxOutputStreamDeviceList_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (ListBoxOutputStreamDeviceList.SelectedIndex >= 0)
            {
                m_selectedOutputStreamDevice = ListBoxOutputStreamDeviceList.SelectedItem as OutputStreamDevice;
                m_originalAcronym = m_selectedOutputStreamDevice.Acronym;
                GridOutputStreamDeviceDetail.DataContext = m_selectedOutputStreamDevice;
                CheckBoxEnabled.IsChecked = m_selectedOutputStreamDevice.Enabled;

                if (string.IsNullOrEmpty(m_selectedOutputStreamDevice.AnalogDataFormat))
                    ComboboxAnalogDataFormat.SelectedIndex = 0;
                else
                    ComboboxAnalogDataFormat.SelectedItem = m_selectedOutputStreamDevice.AnalogDataFormat;

                if (string.IsNullOrEmpty(m_selectedOutputStreamDevice.CoordinateFormat))
                    ComboboxCoordinateFormat.SelectedIndex = 0;
                else
                    ComboboxCoordinateFormat.SelectedItem = m_selectedOutputStreamDevice.CoordinateFormat;

                if (string.IsNullOrEmpty(m_selectedOutputStreamDevice.FrequencyDataFormat))
                    ComboboxFrequencyDataFormat.SelectedIndex = 0;
                else
                    ComboboxFrequencyDataFormat.SelectedItem = m_selectedOutputStreamDevice.FrequencyDataFormat;

                if (string.IsNullOrEmpty(m_selectedOutputStreamDevice.PhasorDataFormat))
                    ComboboxPhasorDataFormat.SelectedIndex = 0;
                else
                    ComboboxPhasorDataFormat.SelectedItem = m_selectedOutputStreamDevice.PhasorDataFormat;
                m_inEditMode = true;
                m_outputStreamDeviceID = m_selectedOutputStreamDevice.ID;

                ButtonSave.Tag = "Update";
            }
        }
Example #3
0
        public static string AddDevices(DataConnection connection, int outputStreamID, Dictionary<int, string> devicesToBeAdded, bool addDigitals, bool addAnalogs)
        {
            bool createdConnection = false;
            try
            {
                if (connection == null)
                {
                    connection = new DataConnection();
                    createdConnection = true;
                }
                foreach (KeyValuePair<int, string> deviceInfo in devicesToBeAdded)	//loop through all the devices that needs to be added.
                {
                    Device device = new Device();
                    device = GetDeviceByDeviceID(connection, deviceInfo.Key);	//Get all the information about the device to be added.
                    OutputStreamDevice outputStreamDevice = new OutputStreamDevice();
                    outputStreamDevice.NodeID = device.NodeID;
                    outputStreamDevice.AdapterID = outputStreamID;
                    outputStreamDevice.Acronym = device.Acronym;
                    outputStreamDevice.BpaAcronym = string.Empty;
                    outputStreamDevice.Name = device.Name;
                    outputStreamDevice.LoadOrder = device.LoadOrder;
                    outputStreamDevice.Enabled = true;
                    outputStreamDevice.PhasorDataFormat = string.Empty;
                    outputStreamDevice.FrequencyDataFormat = string.Empty;
                    outputStreamDevice.AnalogDataFormat = string.Empty;
                    outputStreamDevice.CoordinateFormat = string.Empty;
                    outputStreamDevice.IdCode = device.AccessID;
                    SaveOutputStreamDevice(connection, outputStreamDevice, true, string.Empty);	//save in to OutputStreamDevice Table.

                    int savedOutputStreamDeviceID = GetOutputStreamDevice(connection, outputStreamID, device.Acronym).ID;

                    //********************************************
                    List<Phasor> phasorList = new List<Phasor>();
                    phasorList = GetPhasorList(connection, deviceInfo.Key);			//Get all the phasor information for the device to be added.

                    foreach (Phasor phasor in phasorList)
                    {
                        OutputStreamDevicePhasor outputStreamDevicePhasor = new OutputStreamDevicePhasor(); //Add all phasors one by one into OutputStreamDevicePhasor table.
                        outputStreamDevicePhasor.NodeID = device.NodeID;
                        outputStreamDevicePhasor.OutputStreamDeviceID = savedOutputStreamDeviceID;
                        outputStreamDevicePhasor.Label = phasor.Label;
                        outputStreamDevicePhasor.Type = phasor.Type;
                        outputStreamDevicePhasor.Phase = phasor.Phase;
                        outputStreamDevicePhasor.LoadOrder = phasor.SourceIndex;
                        outputStreamDevicePhasor.ScalingValue = 0;
                        SaveOutputStreamDevicePhasor(connection, outputStreamDevicePhasor, true);
                    }
                    //********************************************

                    //********************************************
                    List<Measurement> measurementList = new List<Measurement>();
                    measurementList = GetMeasurementsByDevice(connection, deviceInfo.Key);

                    int analogIndex = 0;
                    foreach (Measurement measurement in measurementList)
                    {
                        if (measurement.SignalAcronym != "STAT")
                        {
                            OutputStreamMeasurement outputStreamMeasurement = new OutputStreamMeasurement();
                            outputStreamMeasurement.NodeID = device.NodeID;
                            outputStreamMeasurement.AdapterID = outputStreamID;
                            outputStreamMeasurement.HistorianID = measurement.HistorianID;
                            outputStreamMeasurement.PointID = measurement.PointID;
                            outputStreamMeasurement.SignalReference = measurement.SignalReference;

                            if (measurement.SignalAcronym == "ALOG")
                            {
                                if (addAnalogs)
                                {
                                    SaveOutputStreamMeasurement(connection, outputStreamMeasurement, true);

                                    OutputStreamDeviceAnalog outputStreamDeviceAnalog = new OutputStreamDeviceAnalog();
                                    outputStreamDeviceAnalog.NodeID = device.NodeID;
                                    outputStreamDeviceAnalog.OutputStreamDeviceID = savedOutputStreamDeviceID;
                                    outputStreamDeviceAnalog.Label = device.Acronym.Length > 12 ? device.Acronym.Substring(0, 12) + ":A" + analogIndex.ToString() : device.Acronym + ":A" + analogIndex.ToString(); // measurement.PointTag;
                                    outputStreamDeviceAnalog.Type = 0;	//default
                                    outputStreamDeviceAnalog.LoadOrder = Convert.ToInt32(measurement.SignalReference.Substring((measurement.SignalReference.LastIndexOf("-") + 3)));
                                    outputStreamDeviceAnalog.ScalingValue = 0;
                                    SaveOutputStreamDeviceAnalog(connection, outputStreamDeviceAnalog, true);
                                    analogIndex += 1;
                                }
                            }
                            else if (measurement.SignalAcronym == "DIGI")
                            {
                                if (addDigitals)
                                {
                                    SaveOutputStreamMeasurement(connection, outputStreamMeasurement, true);

                                    OutputStreamDeviceDigital outputStreamDeviceDigital = new OutputStreamDeviceDigital();
                                    outputStreamDeviceDigital.NodeID = device.NodeID;
                                    outputStreamDeviceDigital.OutputStreamDeviceID = savedOutputStreamDeviceID;
                                    outputStreamDeviceDigital.Label = digitalLabel;     // measurement.PointTag;
                                    outputStreamDeviceDigital.LoadOrder = Convert.ToInt32(measurement.SignalReference.Substring((measurement.SignalReference.LastIndexOf("-") + 3)));
                                    outputStreamDeviceDigital.MaskValue = 0;
                                    SaveOutputStreamDeviceDigital(connection, outputStreamDeviceDigital, true);
                                }
                            }
                            else
                                SaveOutputStreamMeasurement(connection, outputStreamMeasurement, true);

                        }
                    }
                    //********************************************
                }

                return "Output Stream Device(s) Added Successfully";
            }
            finally
            {
                if (createdConnection && connection != null)
                    connection.Dispose();
            }
        }
        void ButtonSave_Click(object sender, RoutedEventArgs e)
        {
            #if SILVERLIGHT
            Storyboard sb = new Storyboard();
            sb = Application.Current.Resources["ButtonPressAnimation"] as Storyboard;
            sb.Completed += new EventHandler(delegate(object obj, EventArgs es) { sb.Stop(); });
            Storyboard.SetTarget(sb, ButtonSaveTransform);
            sb.Begin();
            #endif
            if (IsValid())
            {
                OutputStreamDevice outputStreamDevice = new OutputStreamDevice();
                App app = (App)Application.Current;
                outputStreamDevice.NodeID = app.NodeValue;
                outputStreamDevice.AdapterID = m_sourceOutputStreamID;
                outputStreamDevice.Acronym = TextBoxAcronym.Text.CleanText();
                outputStreamDevice.BpaAcronym = TextBoxBPAAcronym.Text.CleanText();
                outputStreamDevice.Name = TextBoxName.Text.CleanText();
                outputStreamDevice.LoadOrder = TextBoxLoadOrder.Text.ToInteger();
                outputStreamDevice.Enabled = (bool)CheckBoxEnabled.IsChecked;
                outputStreamDevice.PhasorDataFormat = ComboboxPhasorDataFormat.SelectedIndex == 0 ? string.Empty : ComboboxPhasorDataFormat.SelectedItem.ToString();
                outputStreamDevice.FrequencyDataFormat = ComboboxFrequencyDataFormat.SelectedIndex == 0 ? string.Empty : ComboboxFrequencyDataFormat.SelectedItem.ToString();
                outputStreamDevice.AnalogDataFormat = ComboboxAnalogDataFormat.SelectedIndex == 0 ? string.Empty : ComboboxAnalogDataFormat.SelectedItem.ToString();
                outputStreamDevice.CoordinateFormat = ComboboxCoordinateFormat.SelectedIndex == 0 ? string.Empty : ComboboxCoordinateFormat.SelectedItem.ToString();
                outputStreamDevice.IdCode = TextBoxIDCode.Text.ToInteger();

                if (m_inEditMode == true && m_outputStreamDeviceID > 0)
                {
                    outputStreamDevice.ID = m_outputStreamDeviceID;
                    SaveOutputStreamDevice(outputStreamDevice, false, m_originalAcronym);
                }
                else
                    SaveOutputStreamDevice(outputStreamDevice, true, string.Empty);
            }
        }
Example #5
0
        public static string SaveOutputStreamDevice(DataConnection connection, OutputStreamDevice outputStreamDevice, bool isNew, string originalAcronym)
        {
            //DataConnection connection = new DataConnection();
            bool createdConnection = false;

            try
            {
                if (connection == null)
                {
                    connection = new DataConnection();
                    createdConnection = true;
                }

                IDbCommand command = connection.Connection.CreateCommand();
                command.CommandType = CommandType.Text;

                if (isNew)
                    command.CommandText = "Insert Into OutputStreamDevice (NodeID, AdapterID, IDCode, Acronym, BpaAcronym, Name, LoadOrder, Enabled, PhasorDataFormat, FrequencyDataFormat, AnalogDataFormat, CoordinateFormat, UpdatedBy, UpdatedOn, CreatedBy, CreatedOn) " +
                        "Values (@nodeID, @adapterID, @idCode, @acronym, @bpaAcronym, @name, @loadOrder, @enabled, @phasorDataFormat, @frequencyDataFormat, @analogDataFormat, @coordinateFormat, @updatedBy, @updatedOn, @createdBy, @createdOn)";
                else
                    command.CommandText = "Update OutputStreamDevice Set NodeID = @nodeID, AdapterID = @adapterID, IDCode = @idCode, Acronym = @acronym, " +
                        "BpaAcronym = @bpaAcronym, Name = @name, LoadOrder = @loadOrder, Enabled = @enabled, PhasorDataFormat = @phasorDataFormat, " +
                        "FrequencyDataFormat = @frequencyDataFormat, AnalogDataFormat = @analogDataFormat, CoordinateFormat = @coordinateFormat, UpdatedBy = @updatedBy, UpdatedOn = @updatedOn Where ID = @id";

                command.Parameters.Add(AddWithValue(command, "@nodeID", outputStreamDevice.NodeID));
                command.Parameters.Add(AddWithValue(command, "@adapterID", outputStreamDevice.AdapterID));
                command.Parameters.Add(AddWithValue(command, "@idCode", outputStreamDevice.IdCode));
                command.Parameters.Add(AddWithValue(command, "@acronym", outputStreamDevice.Acronym.Replace(" ", "").ToUpper()));
                command.Parameters.Add(AddWithValue(command, "@bpaAcronym", outputStreamDevice.BpaAcronym.Replace(" ", "").ToUpper()));
                command.Parameters.Add(AddWithValue(command, "@name", outputStreamDevice.Name));
                command.Parameters.Add(AddWithValue(command, "@loadOrder", outputStreamDevice.LoadOrder));
                command.Parameters.Add(AddWithValue(command, "@enabled", outputStreamDevice.Enabled));
                command.Parameters.Add(AddWithValue(command, "@phasorDataFormat", outputStreamDevice.PhasorDataFormat));
                command.Parameters.Add(AddWithValue(command, "@frequencyDataFormat", outputStreamDevice.FrequencyDataFormat));
                command.Parameters.Add(AddWithValue(command, "@analogDataFormat", outputStreamDevice.AnalogDataFormat));
                command.Parameters.Add(AddWithValue(command, "@coordinateFormat", outputStreamDevice.CoordinateFormat));
                command.Parameters.Add(AddWithValue(command, "@updatedBy", s_currentUser));
                command.Parameters.Add(AddWithValue(command, "@updatedOn", command.Connection.ConnectionString.Contains("Microsoft.Jet.OLEDB") ? DateTime.UtcNow.Date : DateTime.UtcNow));

                if (isNew)
                {
                    command.Parameters.Add(AddWithValue(command, "@createdBy", s_currentUser));
                    command.Parameters.Add(AddWithValue(command, "@createdOn", command.Connection.ConnectionString.Contains("Microsoft.Jet.OLEDB") ? DateTime.UtcNow.Date : DateTime.UtcNow));
                }
                else
                {
                    command.Parameters.Add(AddWithValue(command, "@id", outputStreamDevice.ID));

                    //if output stream device is updated then modify signal references in the measurement table
                    //to reflect changes in the acronym of the device. Do this only if new and original acronyms are different.
                    if (!string.IsNullOrEmpty(originalAcronym) && originalAcronym != outputStreamDevice.Acronym)
                    {
                        //Microsoft Access does not support REPLACE function in SQL statement.
                        if (command.Connection.ConnectionString.Contains("Microsoft.Jet.OLEDB"))
                        {
                            List<OutputStreamMeasurement> outputStreamMeasurements = GetOutputStreamMeasurementList(connection, outputStreamDevice.AdapterID);
                            foreach (OutputStreamMeasurement osm in outputStreamMeasurements)
                            {
                                if (osm.SignalReference.StartsWith(originalAcronym + "-"))
                                {
                                    osm.SignalReference = osm.SignalReference.Replace(originalAcronym, outputStreamDevice.Acronym);
                                    SaveOutputStreamMeasurement(connection, osm, false);
                                }
                            }
                        }
                        else
                        {
                            IDbCommand command1 = connection.Connection.CreateCommand();
                            command1.CommandType = CommandType.Text;
                            command1.CommandText = "Update OutputStreamMeasurement Set SignalReference = Replace(SignalReference, @originalAcronym, @newAcronym) Where AdapterID = @adapterID";	// and SignalReference LIKE @signalReference";
                            command1.Parameters.Add(AddWithValue(command1, "@originalAcronym", originalAcronym));
                            command1.Parameters.Add(AddWithValue(command1, "@newAcronym", outputStreamDevice.Acronym));
                            command1.Parameters.Add(AddWithValue(command1, "@adapterID", outputStreamDevice.AdapterID));
                            command1.ExecuteNonQuery();
                        }
                    }
                }

                command.ExecuteNonQuery();

                if (isNew && outputStreamDevice.IdCode == 0)
                {
                    //TODO: update IDCode to auto generated ID value.
                    OutputStreamDevice deviceJustAdded = GetOutputStreamDevice(connection, outputStreamDevice.AdapterID, outputStreamDevice.Acronym.Replace(" ", "").ToUpper());
                    command = connection.Connection.CreateCommand();
                    command.CommandType = CommandType.Text;
                    command.CommandText = "Update OutputStreamDevice SET IDCode = @idCode Where ID = @id";
                    command.Parameters.Add(AddWithValue(command, "@idCode", deviceJustAdded.ID));
                    command.Parameters.Add(AddWithValue(command, "@id", deviceJustAdded.ID));
                    command.ExecuteNonQuery();
                }

                return "Output Stream Device Information Saved Successfully";
            }
            finally
            {
                if (createdConnection && connection != null)
                    connection.Dispose();
            }
        }