/// <summary>
/// Binds the device tags to the configuration database.
/// </summary>
public virtual void BindDeviceTags(BaseDataSet baseDataSet)
{
foreach (InCnl inCnl in baseDataSet.InCnlTable.SelectItems(new TableFilter("DeviceNum", DeviceNum), true))
{
if (inCnl.Active && inCnl.CnlTypeID == CnlTypeID.Measured)
{
DeviceTag deviceTag = null;
if (!string.IsNullOrEmpty(inCnl.TagCode))
{
// find tag by code
DeviceTags.TryGetTag(inCnl.TagCode, out deviceTag);
}
else if (inCnl.TagNum > 0)
{
// find tag by index
DeviceTags.TryGetTag(inCnl.TagNum.Value - 1, out deviceTag);
}
// check match and bind tag
if (deviceTag != null &&
(int)deviceTag.DataType == (inCnl.DataTypeID ?? DataTypeID.Double) &&
deviceTag.DataLength == Math.Max(inCnl.DataLen ?? 1, 1))
{
deviceTag.InCnl = inCnl;
}
}
}
}
public ChildDataSet(BaseDataSet baseDataSet, DataRow parentRow)
: base(baseDataSet._)
{
Debug.Assert(baseDataSet != null);
_baseDataSet = baseDataSet;
_parentRow = parentRow;
}
public override global::System.Data.DataSet Clone()
{
BaseDataSet cln = ((BaseDataSet)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return(cln);
}
public AuditoriumInfo(BaseDataSet.AuditoriumsRow p)
{
Number = p.Number;
ID_Auditorium = p.ID_Auditorium;
Capacity = p.Capacity;
NumbComp = p.NumbComp;
QualityComp = p.QualityComp;
AvailabilityProjector = p.AvailabilityProjector;
ID_Location = p.ID_Location;
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs)
{
BaseDataSet ds = new BaseDataSet();
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
global::System.Xml.Schema.XmlSchemaAny any = new global::System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace))
{
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext();)
{
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length))
{
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length) &&
(s1.ReadByte() == s2.ReadByte()));)
{
;
}
if ((s1.Position == s1.Length))
{
return(type);
}
}
}
}
finally {
if ((s1 != null))
{
s1.Close();
}
if ((s2 != null))
{
s2.Close();
}
}
}
xs.Add(dsSchema);
return(type);
}
private void UpdateDataSetRevision()
{
if (IsEditing)
{
return;
}
BaseDataSet.UpdateRevision();
if (DataSet != BaseDataSet)
{
DataSet.UpdateRevision();
}
}
/// <summary>
/// Calls the BindDeviceTags method of the device.
/// </summary>
public void BindDeviceTags(BaseDataSet baseDataSet)
{
try
{
if (DeviceLogic.IsBound && baseDataSet != null)
{
DeviceLogic.BindDeviceTags(baseDataSet);
}
}
catch (Exception ex)
{
log.WriteException(ex, CommPhrases.ErrorInDevice, nameof(BindDeviceTags), DeviceLogic.Title);
}
}
/// <summary>
/// Reads the configuration database.
/// </summary>
public override bool ReadBase(out BaseDataSet baseDataSet)
{
// do not read the configuration database from the server that likely contains partial data
if (deviceFilter != null)
{
baseDataSet = null;
return(false);
}
string tableName = Locale.IsRussian ? "неопределена" : "undefined";
try
{
log.WriteAction(CommPhrases.DataSourceMessage, Code, Locale.IsRussian ?
"Приём базы конфигурации" :
"Receive the configuration database");
ScadaClient localClient = new ScadaClient(connOptions);
baseDataSet = new BaseDataSet();
foreach (IBaseTable baseTable in baseDataSet.AllTables)
{
tableName = baseTable.Name;
localClient.DownloadBaseTable(baseTable);
}
localClient.TerminateSession();
log.WriteAction(CommPhrases.DataSourceMessage, Code, Locale.IsRussian ?
"База конфигурации получена успешно" :
"The configuration database has been received successfully");
return(true);
}
catch (Exception ex)
{
log.WriteException(ex, CommPhrases.DataSourceMessage, Code, string.Format(Locale.IsRussian ?
"Ошибка при приёме базы конфигурации, таблица {0}" :
"Error receiving the configuration database, the {0} table", tableName));
baseDataSet = null;
return(false);
}
}
/// <summary>
/// Calls the ReadBase method of the data sources.
/// </summary>
public bool ReadBase(out BaseDataSet baseDataSet)
{
foreach (DataSourceLogic dataSourceLogic in dataSources)
{
try
{
if (dataSourceLogic.IsReady)
{
if (dataSourceLogic.ReadBase(out baseDataSet))
{
return(true);
}
}
}
catch (Exception ex)
{
log.WriteException(ex, CommPhrases.ErrorInDataSource, nameof(ReadBase), dataSourceLogic.Code);
}
}
baseDataSet = null;
return(false);
}
/// <summary>
/// Initializes the access control.
/// </summary>
public void Init(BaseDataSet baseDataSet)
{
if (baseDataSet == null)
{
throw new ArgumentNullException(nameof(baseDataSet));
}
// initialize rights matrix
rightsMatrix = new Dictionary <int, RightsByObj>(baseDataSet.RoleTable.ItemCount);
// create indexes
TableIndex roleRef_childRoleIndex = new TableIndex("ChildRoleID", typeof(RoleRef));
roleRef_childRoleIndex.AddRangeToIndex(baseDataSet.RoleRefTable.Items);
TableIndex objRight_roleIndex = new TableIndex("RoleID", typeof(ObjRight));
objRight_roleIndex.AddRangeToIndex(baseDataSet.ObjRightTable.Items);
TableIndex obj_parentObjIndex = new TableIndex("ParentObjNum", typeof(Obj));
obj_parentObjIndex.AddRangeToIndex(baseDataSet.ObjTable.Items);
// fill rights
foreach (Role role in baseDataSet.RoleTable.EnumerateItems())
{
int roleID = role.RoleID;
RightsByObj rightsByObj = new RightsByObj();
rightsMatrix.Add(roleID, rightsByObj);
AddRoleRights(objRight_roleIndex, obj_parentObjIndex, rightsByObj, roleID);
foreach (int parentRoleID in EnumerateParentRoleIDs(roleRef_childRoleIndex, roleID))
{
AddRoleRights(objRight_roleIndex, obj_parentObjIndex, rightsByObj, parentRoleID);
}
}
}
/// <summary>
/// Parse the incoming packet for all the Data Sets.
/// Add the data to a AdcpDataSet variable and
/// return the filled variable when complete.
/// </summary>
/// <param name="binaryEnsemble">Byte array containing data from an ADCP.</param>
/// <returns>Object holding decoded ADCP data.</returns>
public DataSet.EnsemblePackage DecodeAdcpData(byte[] binaryEnsemble)
{
// Keep track where in the packet
// we are currently decoding
int packetPointer = DataSet.Ensemble.ENSEMBLE_HEADER_LEN;
int type = 0;
int numElements = 0;
int elementMultiplier = 0;
int imag = 0;
int nameLen = 0;
string name = "";
int dataSetSize = 0;
Ensemble ensemble = new Ensemble();
for (int i = 0; i < DataSet.Ensemble.MAX_NUM_DATA_SETS; i++)
{
//Debug.Print("binaryEnsemble: " + binaryEnsemble.Length + " packetPointer: " + packetPointer + "\n");
type = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 0));
numElements = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 1));
elementMultiplier = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 2));
imag = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 3));
nameLen = MathHelper.ByteArrayToInt32(binaryEnsemble, packetPointer + (DataSet.Ensemble.BYTES_IN_INT32 * 4));
name = MathHelper.ByteArrayToString(binaryEnsemble, 8, packetPointer + (DataSet.Ensemble.BYTES_IN_FLOAT * 5));
// Verify the data is good
if (string.IsNullOrEmpty(name))
{
break;
}
//Debug.Print("name: " + name + "\n");
//Debug.Print("numElements: " + numElements + "\n");
//Debug.Print("elementMultiplier" + elementMultiplier + "\n");
// Get the size of this data set
dataSetSize = BaseDataSet.GetDataSetSize(type, nameLen, numElements, elementMultiplier);
if (Ensemble.BeamVelocityID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] velData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddBeamVelocityData(type, numElements, elementMultiplier, imag, nameLen, name, velData);
//Debug.WriteLine(adcpData.BeamVelocityData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.InstrumentVelocityID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] velData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddInstrumentVelocityData(type, numElements, elementMultiplier, imag, nameLen, name, velData);
//Debug.WriteLine(adcpData.InstrVelocityData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.EarthVelocityID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] velData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddEarthVelocityData(type, numElements, elementMultiplier, imag, nameLen, name, velData);
//Debug.WriteLine(adcpData.EarthVelocityData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.AmplitudeID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ampData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddAmplitudeData(type, numElements, elementMultiplier, imag, nameLen, name, ampData);
//Debug.WriteLine(adcpData.AmplitudeData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.CorrelationID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] corrData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddCorrelationData(type, numElements, elementMultiplier, imag, nameLen, name, corrData);
//Debug.WriteLine(adcpData.CorrelationData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.GoodBeamID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] goodBeamData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddGoodBeamData(type, numElements, elementMultiplier, imag, nameLen, name, goodBeamData);
//Debug.WriteLine(adcpData.GoodBeamData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.GoodEarthID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] goodEarthData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddGoodEarthData(type, numElements, elementMultiplier, imag, nameLen, name, goodEarthData);
//Debug.WriteLine(adcpData.GoodEarthData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.EnsembleDataID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ensembleData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddEnsembleData(type, numElements, elementMultiplier, imag, nameLen, name, ensembleData);
//Debug.WriteLine(adcpData.EnsembleData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.AncillaryID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ancillaryData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddAncillaryData(type, numElements, elementMultiplier, imag, nameLen, name, ancillaryData);
//Debug.WriteLine(adcpData.AncillaryData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.BottomTrackID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] bottomTrackData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddBottomTrackData(type, numElements, elementMultiplier, imag, nameLen, name, bottomTrackData);
//Debug.WriteLine(adcpData.BottomTrackData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.NmeaID.Equals(name, StringComparison.Ordinal))
{
// List of all data read
byte[] nmeaData = new byte[dataSetSize];
// Scan through the data set and store all the data
for (int x = 0; x < dataSetSize; x++)
{
nmeaData[x] = binaryEnsemble[packetPointer++];
}
// Add the data
ensemble.AddNmeaData(type, numElements, elementMultiplier, imag, nameLen, name, nmeaData);
//Debug.WriteLine(adcpData.NmeaData.ToString());
}
else if (Ensemble.ProfileEngineeringID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] peData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddProfileEngineeringData(type, numElements, elementMultiplier, imag, nameLen, name, peData);
//Debug.WriteLine(adcpData.BottomTrackData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.BottomTrackEngineeringID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] bteData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddBottomTrackEngineeringData(type, numElements, elementMultiplier, imag, nameLen, name, bteData);
//Debug.WriteLine(adcpData.BottomTrackData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.SystemSetupID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ssData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddSystemSetupData(type, numElements, elementMultiplier, imag, nameLen, name, ssData);
//Debug.WriteLine(adcpData.BottomTrackData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.RangeTrackingID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] rtData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddRangeTrackingData(type, numElements, elementMultiplier, imag, nameLen, name, rtData);
//Debug.WriteLine(adcpData.RangeTrackingData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.GageHeightID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] ghData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddGageHeightData(type, numElements, elementMultiplier, imag, nameLen, name, ghData);
//Debug.WriteLine(adcpData.GageHeightData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else if (Ensemble.Adcp2InfoID.Equals(name, StringComparison.Ordinal))
{
// Create a sub array of just this data set data
byte[] adcp2InfoData = MathHelper.SubArray <byte>(binaryEnsemble, packetPointer, dataSetSize);
// Add the data
ensemble.AddAdcp2InfoData(type, numElements, elementMultiplier, imag, nameLen, name, adcp2InfoData);
//Debug.WriteLine(adcpData.GageHeightData.ToString());
// Advance the packet pointer
packetPointer += dataSetSize;
}
else
{
// Advance the packet pointer
packetPointer += dataSetSize;
}
//Debug.Print("DataSetSize: " + dataSetSize + "\n");
//Debug.Print(" packetPointer: " + packetPointer + "\n");
if (packetPointer + 4 >= binaryEnsemble.Length || packetPointer < 0)
{
break;
}
}
// If NMEA data is available, add it to the dataset
// Add it to both the binary data and ensemble object
if (_nmeaBuffer.Count > 0)
{
// Create a NMEA dataset
MergeNmeaDataSet(ref ensemble);
// Add the NMEA binary data to binary data
if (ensemble.IsNmeaAvail)
{
MergeNmeaBinary(ref binaryEnsemble, ensemble.NmeaData);
}
}
// Send an event that data was processed
// in this format
//if (ProcessDataEvent != null)
//{
// ProcessDataEvent(binaryEnsemble, ensemble);
//}
// Set the values to return
var pak = new DataSet.EnsemblePackage();
pak.Ensemble = ensemble;
pak.RawEnsemble = binaryEnsemble;
return(pak);
}
public GroupInfo(BaseDataSet.GroupRow p)
{
Name = p.Name;
ID_Group = p.ID_Group;
ID_Education = p.ID_Education;
if (!p.IsID_FacultyNull())
ID_Faculty = ID_Faculty;
}
public FacultyInfo(BaseDataSet.FacultyRow p)
{
Name = p.Name;
ID_Faculty = p.ID_Faculty;
}
/// <summary>
/// Compiles the scripts and formulas.
/// </summary>
public bool CompileScripts(BaseDataSet baseDataSet,
Dictionary <int, CnlTag> cnlTags, Dictionary <int, OutCnlTag> outCnlTags)
{
if (baseDataSet == null)
{
throw new ArgumentNullException(nameof(baseDataSet));
}
if (cnlTags == null)
{
throw new ArgumentNullException(nameof(cnlTags));
}
if (outCnlTags == null)
{
throw new ArgumentNullException(nameof(outCnlTags));
}
try
{
log.WriteAction(Locale.IsRussian ?
"Компиляция исходного кода скриптов и формул" :
"Compile the source code of scripts and formulas");
string sourceCode = GenerateSourceCode(
baseDataSet.InCnlTable, baseDataSet.OutCnlTable, baseDataSet.ScriptTable,
out Dictionary <int, string> inCnlClassNames, out Dictionary <int, string> outCnlClassNames);
SaveSourceCode(sourceCode, out string sourceCodeFileName);
Compilation compilation = PrepareCompilation(sourceCode);
using (MemoryStream memoryStream = new MemoryStream())
{
EmitResult result = compilation.Emit(memoryStream);
if (result.Success)
{
Assembly assembly = Assembly.Load(memoryStream.ToArray());
RetrieveMethods(assembly, cnlTags, outCnlTags, inCnlClassNames, outCnlClassNames);
log.WriteAction(Locale.IsRussian ?
"Исходный код скриптов и формул скомпилирован успешно" :
"The source code of scripts and formulas has been compiled successfully");
return(true);
}
else
{
// write errors to log
log.WriteError(Locale.IsRussian ?
"Ошибка при компиляции исходного кода скриптов и формул:" :
"Error compiling the source code of the scripts and formulas:");
foreach (Diagnostic diagnostic in result.Diagnostics)
{
if (diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error)
{
log.WriteLine(Indent + diagnostic);
}
}
log.WriteLine(Indent + string.Format(Locale.IsRussian ?
"Проверьте исходный код в файле {0}" :
"Check the source code in {0}", sourceCodeFileName));
return(false);
}
}
}
catch (Exception ex)
{
log.WriteException(ex, Locale.IsRussian ?
"Ошибка при компиляции исходного кода скриптов и формул" :
"Error compiling the source code of the scripts and formulas");
return(false);
}
}
public LocationInfo(BaseDataSet.LocationRow p)
{
Name = p.Name;
ID_Location = p.ID_Location;
}
public ScheduleExceptionInfo(BaseDataSet.ScheduleExceptionRow s)
{
ID_Exception = s.ID_Exception;
ID_Auditorium = s.ID_Auditorium;
AuditoriumNumber = s.AuditoriumsRow.Number;
ID_Discipline = s.ID_Discipline;
DisciplineName = s.DisciplinesRow.Name;
ID_Group = s.ID_Group;
GroupName = s.GroupRow.Name;
Day = s.Day;
ID_Teacher = s.ID_Teacher;
TeacherName = s.TeachersRow.Name;
Para = s.Para;
DayWeek = s.DayWeek;
ID_Location = s.AuditoriumsRow.ID_Location;
ID_Faculty = s.GroupRow.ID_Faculty;
}
public PeriodInfo(BaseDataSet.PeriodsRow p)
{
Name = p.Name;
ID_Period = p.ID_Period;
}
public void GetItemsThrowsIfBindingListIsNull()
{
BaseDataSet dataSet = Mocks.PartialMock <BaseDataSet>();
dataSet.GetItems(null, false);
}
public ScheduleInfo(BaseDataSet.ScheduleRow s)
{
ID = s.ID;
ID_Auditorium = s.ID_Auditorium;
AuditoriumNumber = s.AuditoriumsRow.Number;
ID_Discipline = s.ID_Discipline;
DisciplineName = s.DisciplinesRow.Name;
ID_Group = s.ID_Group;
GroupName = s.GroupRow.Name;
ID_Period = s.ID_Period;
PeriodName = s.PeriodsRow.Name;
ID_Teacher = s.ID_Teacher;
TeacherName = s.TeachersRow.Name;
Para = s.Para;
DayWeek = s.DayWeek;
ID_Location = s.AuditoriumsRow.ID_Location;
ID_Faculty = s.GroupRow.ID_Faculty;
LocationName = s.AuditoriumsRow.LocationRow.Name;
}
public void CanBindThrowsIfBindingIsNull()
{
BaseDataSet dataSet = Mocks.PartialMock <BaseDataSet>();
dataSet.CanBind(null);
}
public EducationInfo(BaseDataSet.EducationRow p)
{
Name = p.Name;
ID_Education = p.ID_Education;
}
/// <summary>
/// Reads the configuration database.
/// </summary>
public virtual bool ReadBase(out BaseDataSet baseDataSet)
{
baseDataSet = null;
return(false);
}
public AbridgementInfo(BaseDataSet.AbridgementRow a)
{
ID = a.ID;
Source = a.source;
Abridged = a.abridged;
}
public TeacherInfo(BaseDataSet.TeachersRow p)
{
Name = p.Name;
ID_Teacher = p.ID_Teacher;
}
/// <summary>
/// Binds the device to the configuration database.
/// </summary>
public virtual void Bind(BaseDataSet baseDataSet)
{
}
public DisciplineInfo(BaseDataSet.DisciplinesRow p)
{
Name = p.Name;
ID_Discipline = p.ID_Discipline;
}
