public async Task RunBotAsync()
{
PlayerList = new List <PlayerConfig>();
Client = new DiscordSocketClient();
Commands = new CommandService();
_service = new ServiceCollection();
_service.AddSingleton(Client);
_service.AddSingleton(Commands);
Services = _service.BuildServiceProvider();
string botToken = "";
//event subscriptions
Client.Log += Log;
DataSets.InitialiseDataSet();
await RegisterCommandsAsync();
await Client.LoginAsync(TokenType.Bot, botToken);
await Client.StartAsync();
await Task.Delay(-1);
}
public void WriteTo(XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("Report");
{
// Namespaces
xmlWriter.WriteAttributeString("xmlns", "", null, "http://schemas.microsoft.com/sqlserver/reporting/2005/01/reportdefinition");
xmlWriter.WriteAttributeString("xmlns", "rd", null, "http://schemas.microsoft.com/SQLServer/reporting/reportdesigner");
DataSources.WriteTo(xmlWriter);
Margin.WriteTo(xmlWriter);
xmlWriter.WriteElementString("rd:ReportID", rdReportID);
if (EmbeddedImages.Count > 0)
{
EmbeddedImages.WriteTo(xmlWriter);
}
//design properties
xmlWriter.WriteElementString("rd:DrawGrid", RdlcWrapper.RdlcValueConverter.GetBoolean(DrawGrid));
xmlWriter.WriteElementString("rd:SnapToGrid", RdlcWrapper.RdlcValueConverter.GetBoolean(SnapToGrid));
Body.WriteTo(xmlWriter);
xmlWriter.WriteElementString("Width", Width.ToString());
xmlWriter.WriteElementString("InteractiveHeight", InteractiveHeight.ToString());
xmlWriter.WriteElementString("InteractiveWidth", InteractiveWidth.ToString());
xmlWriter.WriteElementString("Language", Language);
DataSets.WriteTo(xmlWriter);
}
xmlWriter.WriteEndElement();
}
public void addTable(DataSets ds, string tableName, Dictionary <string, Type> columns, params string[] primaryKeys)
{
if (m_dataSets[ds].Tables.Contains(tableName))
{
throw new AlreadyInitializedError("Table already exists in this data set");
}
try
{
m_writeSems[ds].WaitOne();
m_dataSets[ds].Tables.Add(tableName);
foreach (KeyValuePair <string, Type> kvPair in columns)
{
m_dataSets[ds].Tables[tableName].Columns.Add(kvPair.Key, kvPair.Value);
}
DataColumn[] primaryKeyColumnsList = new DataColumn[primaryKeys.Length];
for (int index = 0; index < primaryKeys.Length; index++)
{
primaryKeyColumnsList[index] = m_dataSets[ds].Tables[tableName].Columns[primaryKeys[index]];
}
m_dataSets[ds].Tables[tableName].PrimaryKey = primaryKeyColumnsList;
}
finally
{
m_writeSems[ds].Release();
}
}
/// <summary>
///
/// </summary>
/// <returns>true if the value needed to be added to the table</returns>
public bool setValues(DataSets ds, string tableName, Dictionary <string, object> values)
{
string primaryKey = m_dataSets[ds].Tables[tableName].PrimaryKey[0].ColumnName;
DataRow row = m_dataSets[ds].Tables[tableName].Rows.Find(values[primaryKey]);
if (row == null)
{
addValuesToEnd(ds, tableName, values);
return(true);
}
try
{
m_writeSems[ds].WaitOne();
foreach (KeyValuePair <string, object> pair in values)
{
row[pair.Key] = pair.Value;
}
return(false);
}
finally
{
m_writeSems[ds].Release();
}
}
protected DataCatalogue(int tenantId) : base()
{
TenantId = tenantId;
Name = String.Empty;
NumberofDatasets = DataSets.Count();
TotalItemsCount = 0;
}
public ActionResult DataSetCreated(DataSets dataSet)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "Something went wrong!");
return(View("CreateDataSet"));
}
List <DataSetFileDetail> fileDetails = new List <DataSetFileDetail>();
for (int i = 0; i < Request.Files.Count; i++)
{
var file = Request.Files[i];
if (file != null && file.ContentLength > 0)
{
var fileName = Path.GetFileName(file.FileName);
DataSetFileDetail fileDetail = new DataSetFileDetail()
{
FileName = fileName,
Extension = Path.GetExtension(fileName),
FileDataId = Guid.NewGuid().ToString()
};
fileDetails.Add(fileDetail);
var path = Path.Combine(Server.MapPath("~/App_Data/Upload/"), fileDetail.FileDataId + fileDetail.Extension);
file.SaveAs(path);
}
}
dataSet.DataSetFileDetail = fileDetails;
_context.DataSets.Add(dataSet);
_context.SaveChanges();
return(RedirectToAction("All"));
}
public ActionResult DataSetDeleted(int id)
{
DataSets dataSet = _context.DataSets.FirstOrDefault(x => x.Id == id);
var dataSetList = _context.DataSetFileDetail.Where(x => x.DataSetId == id).ToList();
foreach (var item in dataSetList)
{
DataSetFileDetail fileDetail = _context.DataSetFileDetail.FirstOrDefault(x => x.FileDataId == item.FileDataId);
_context.DataSetFileDetail.Remove(fileDetail);
_context.SaveChanges();
var path = Path.Combine(Server.MapPath("~/App_Data/Upload/"), fileDetail.FileDataId + fileDetail.Extension);
if (System.IO.File.Exists(path))
{
System.IO.File.Delete(path);
}
}
_context.DataSets.Remove(dataSet);
_context.SaveChanges();
return(RedirectToAction("All"));
}
/// <summary>
/// Initializes a new instance of the <see cref="ToolDialog"/> class.
/// </summary>
/// <param name="tool">The ITool to create the dialog box for</param>
/// <param name="modelElements">A list of all model elements</param>
public ToolDialog(ITool tool, IEnumerable <ModelElement> modelElements)
{
// Required by the designer
InitializeComponent();
// We store all the element names here and extract the datasets
foreach (ModelElement me in modelElements)
{
DataElement de = me as DataElement;
if (de != null)
{
bool addData = true;
foreach (Parameter par in tool.OutputParameters)
{
if (par.ModelName == de.Parameter.ModelName)
{
addData = false;
}
break;
}
if (addData)
{
DataSets.Add(new DataSetArray(me.Name, de.Parameter.Value as IDataSet));
}
}
}
Initialize(tool);
}
public bool FilterByRetentionTime()
{
// Now that we have times loaded, apply explicit RT filter if any
if (ExplicitRetentionTime != null)
{
double explicitRT = ExplicitRetentionTime.RetentionTime;
for (var i = DataSets.Count - 1; i >= 0; i--)
{
var dataSet = DataSets[i];
if (explicitRT < dataSet.MinRawTime || dataSet.MaxRawTime < explicitRT)
{
DataSets.RemoveAt(i);
}
else
{
for (var j = dataSet.Chromatograms.Count - 1; j >= 0; j--)
{
var chrom = dataSet.Chromatograms[j];
if (explicitRT < chrom.Times.First() || chrom.Times.Last() < explicitRT)
{
dataSet.Chromatograms.RemoveAt(j);
}
}
}
}
}
return(DataSets.Any());
}
void ValidateDataSets()
{
foreach (var dataSet in DataSets.Where(dataSet => Entities.All(e => e.Name != dataSet.Name)))
{
Error("The {0} data set does not match any entities (by name).", dataSet.Name);
}
}
static Dictionary()
{
string[] words;
var dictionary = Program.CurrentOptions?.Dictionary ?? Options.Default.Dictionary;
try {
{
using FileStream file = File.OpenRead(dictionary);
if (Path.GetExtension(dictionary).EqualsInvariantInsensitive(".zip"))
{
using ZipArchive zip = new(file, ZipArchiveMode.Read, leaveOpen : false);
using StreamReader reader = new(zip.Entries[0].Open());
words = reader.ReadToEnd().Replace('\r', '\n').Split('\n', StringSplitOptions.RemoveEmptyEntries);
}
else
{
using StreamReader reader = new(file);
words = reader.ReadToEnd().Replace('\r', '\n').Split('\n', StringSplitOptions.RemoveEmptyEntries);
}
}
}
catch (Exception ex) {
throw new Exception($"Failed to open dictionary file '{dictionary}'");
}
void AddSet(in DataSet <string[]> dataSet)
{
DataSets.Add(dataSet);
}
AddSet(new(words));
}
public void addNodes(DataSets.dsModuleStructure3.dtStepCompositeRow row, TreeNode parentNode)
{
TreeNode treeNode = new StepCompositeNode(row);
DataSets.dsModuleStructure3.dtModuleRow module = getSelectedModuleRow();
if(row.dtModuleRow.fk_module_type == module.fk_module_type)
{
if (parentNode == null)
{
tlvSteps.Nodes.Add(treeNode);
}
else
{
parentNode.Nodes.Add(treeNode);
}
foreach (DataSets.dsModuleStructure3.dtStepCompositeRow childRows in row.GetdtStepCompositeRows())
{
addNodes(childRows, treeNode);
}
foreach (DataSets.dsModuleStructure3.dtStepLeafRow stepLeafRow in row.GetdtStepLeafRows())
{
TreeNode stepLeafNode = new StepLeafNode(stepLeafRow, _dsModuleStructure.dtActionValue);
treeNode.Nodes.Add(stepLeafNode);
}
}
}
public optionModuleTypeLabwareParameterType(DataSets.dsModuleStructure3 dsModuleStructure)
: this()
{
this.dsModuleStructureGUI = dsModuleStructure;
this.bsModuleType.DataSource = dsModuleStructureGUI;
bsLabwareParameterType.DataSource = dsModuleStructureGUI;
this.bsModuleTypedtModuleTypeLabwareParameterType.DataMember = "dtModuleType_dtModuleTypeLabwareParameterType";
this.bsModuleTypedtModuleTypeLabwareParameterType.DataSource = this.bsModuleType;
/*
this.dsLabwareStructureGUI = dtLabwareStructure;
this.dsModuleStructureGUI = dsModuleStructure;
bsLabwareType.DataSource = dsLabwareStructureGUI;
bsLabwareTypeLabwareParameterType.DataSource = dsLabwareStructureGUI;
if(dsLabwareStructureGUI.dtLabwareParameterType.Count == 0)
{
taLabwareParameterType.Fill(dsLabwareStructureGUI.dtLabwareParameterType);
}
if(dsLabwareStructureGUI.dtLabwareType.Count == 0)
{
taLabwareType.Fill(dsLabwareStructureGUI.dtLabwareType);
}
* */
}
private void Button_Click_Load_Sets(object sender, RoutedEventArgs e)
{
OpenFileDialog fd = new OpenFileDialog();
var result = fd.ShowDialog();
if (result.Value)
{
DataSets dataSets = Serialization.Deserialize(fd.FileName);
ChosenSet = dataSets.articles;
if (dataSets.category == "Orgs")
{
createdDataCheckBox.IsChecked = true;
selectCategoryComboBox.IsEnabled = false;
selectCategoryComboBox.Items.Add("Orgs");
selectCategoryComboBox.Text = "Orgs";
}
else
{
selectCategoryComboBox.Text = dataSets.category;
createdDataCheckBox.IsChecked = false;
selectCategoryComboBox.IsEnabled = true;
}
beginClasificationButton.IsEnabled = true;
saveSets.IsEnabled = true;
}
}
public ImportedDataSet ImportedDataSetAt(int index)
{
var sheetIndex = 0;
var sheet = DataSets.GetEnumerator();
var accumulatedIndexes = 0;
while (sheet.MoveNext() && index >= 0)
{
if (sheet.Current.Data.Count() > index)
{
var dataSet = sheet.Current.Data.ElementAt(index);
return(new ImportedDataSet(
_configuration.FileName,
DataSets.Keys.ElementAt(sheetIndex),
dataSet,
NamesFromConvention().ElementAt(accumulatedIndexes + index),
dataSet.EnumerateMetaData(_mappings)
));
}
index -= sheet.Current.Data.Count();
sheetIndex++;
accumulatedIndexes += sheet.Current.Data.Count();
}
return(null);
}
private static void AddErrorCases(Random random)
{
{
// error case
Vector2I outerDimensions = (704, 2256);
uint[] data = GC.AllocateUninitializedArray <uint>(outerDimensions.Area);
random.NextBytes(data.AsSpan().AsBytes());
Bounds innerBounds = new((703, 1912), (1, 264));
ReadOnlySpan <byte> dataBytes = data.AsSpan().AsBytes();
var format = SurfaceFormat.Color;
var actualWidth = format.SizeBytes(innerBounds.Extent.X);
var rawStride = format.SizeBytes(outerDimensions.Width);
var rawOffset = (rawStride * innerBounds.Top) + format.SizeBytes(innerBounds.Left);
SpriteDataSet set = new(
false,
new(
array : dataBytes.ToArray(),
offset : rawOffset,
width : actualWidth,
height : innerBounds.Extent.Y,
pitch : rawStride - actualWidth
)
);
DataSets.Add(set);
}
}
public DTWExperiment(bool includeTime, string setName, bool crossValidate, int nTrainingOrSubsets, double pointDistance = 0)
{
this.includeTime = includeTime;
this.dataSourceName = setName;
this.nTrainingOrSubsets = nTrainingOrSubsets;
this.crossValidate = crossValidate;
this.pointDistance = pointDistance;
ISubsetCreator subsetCreator = crossValidate ?
new CrossvalidationSubsetCreator(nTrainingOrSubsets) :
(ISubsetCreator) new SimpleSplitSubsetCreator(nTrainingOrSubsets);
var traceProcessor = (pointDistance > 0) ? new DynamicAreaPointSampling(pointDistance) : null;
GestureDataSet allGestures = DataSets.getTrajectoryDataSet(setName);
if (traceProcessor != null)
{
allGestures = traceProcessor.processAllGestures(allGestures);
}
subsetCreator.createSubsets(allGestures);
trainingSubSets = subsetCreator.getTrainingSubsets();
testSubSets = subsetCreator.getTestSubsets();
}
private async void Delete()
{
Log.Info(LogMessages.ManageDataSetDeleteCommand);
if (SelectedDataSet == null)
{
return;
}
var context = new CommonDialogViewModel
{
Buttons = ButtonsEnum.YesNo,
Header = "Delete dataset",
Content = new JContent("Are you sure to remove the following data set: " + SelectedDataSet.Name)
};
var view = new CommonDialog {
DataContext = context
};
var canClose = false;
var result = await _dialogHandler.Show(view, "RootDialog",
async (object sender, DialogClosingEventArgs args) =>
{
if (!canClose && (CommonDialogResult)args.Parameter == CommonDialogResult.Yes)
{
args.Cancel();
args.Session.UpdateContent(new ProgressDialog());
var isSuccessful = false;
var errorMessage = "";
try
{
var response = await _dataSetManager.DeleteDataSetAsync(SelectedDataSet.Name);
isSuccessful = response.IsSuccessful;
ResponseValidator.Validate(response, false);
}
catch (Exception exception)
{
isSuccessful = false;
errorMessage = exception.Message;
}
finally
{
if (!isSuccessful)
{
context.ErrorMessage = errorMessage;
context.ShowError = true;
args.Session.UpdateContent(view);
}
else
{
canClose = true;
args.Session.Close((CommonDialogResult)args.Parameter);
}
}
}
});
if ((CommonDialogResult)result == CommonDialogResult.Yes)
{
DispatcherHelper.CheckBeginInvokeOnUI(() => DataSets.Remove(SelectedDataSet));
}
}
public override global::System.Data.DataSet Clone()
{
DataSets cln = ((DataSets)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return(cln);
}
/// <summary>
/// Constructor for the class
/// </summary>
public TabOrderDialog(Page page, DataSets.TabOrders.TabOrderDataTable tabOrderForFields)
{
// This call is required by the Windows Form Designer.
InitializeComponent();
currentPage = page;
currentView = page.GetView();
fieldsTabOrder = tabOrderForFields;
}
/// <summary>
/// Initializes the data.
/// </summary>
private void InitData()
{
WaitCursor.Show();
EntityTopics = Load <TopicCategory>();
EntityMeasures = Load <Measure>();
DataSets = GetDatasetForMeasure(); // Load<Target>().Select(x => x.Name).ToList();
DataSets.Insert(0, ALL_DATASETS);
}
public void TrainForSingleDataset(DataSets dataSet, int epochs)
{
for (var i = 0; i < epochs; i++)
{
ForwardPropagate(dataSet.Values);
BackPropagate(dataSet.Targets);
}
}
/// <summary>
/// add's data to the chart. At least one set of data is needed to create the chart, when supplying multiple sets of data a multi-bar column charts is created.
/// Number of columns and the columns label's are determined from the first set of data only.
/// </summary>
public void AddDataSet(DataSet data)
{
//add dataset
DataSets.Add(data);
//keep track of items
NumberOfColumns = DataSets.First().Data.Count;
BarsPerColumn = DataSets.Count;
}
public void initDeck(DataSets.dsModuleStructure3 dsModuleStructure, BindingSource bsModule)
{
this.dsModuleStructure31 = dsModuleStructure;
this.bs1=bsModule;
bsModule.DataSource = this.dsModuleStructure31;
this.bs1.DataMember = "dtModule";
this.bs1.DataSource = this.dsModuleStructure31;
}
public Report(Report report)
{
Name = report.Name;
DataSets = new DataSets(report.DataSets);
Body = new Body(report.Body);
PageHeader = new PageHeader(report.PageHeader);
PageFooter = new PageFooter(report.PageFooter);
DisplayTitle = report.DisplayTitle;
}
public Uri GetReportDocument(DataSets.SinglePlayerHistory ds)
{
FileInfo xmlData = new FileInfo("report_data.xml");
FileInfo f = new FileInfo("report.html");
Uri link = new Uri(f.FullName);
if (f.Exists)
f.Delete();
if (xmlData.Exists)
xmlData.Delete();
var html = HtmlTop;
foreach (DataRow pDr in ds.Player.Rows)
{
html += "\r\n<br><br><h3>" + pDr["NickName"].ToString() + "</h3>\r\n";
html += "<table border='0' width='100%'>\r\n";
html += "<tr><td width='33%'>Name</td><td width='33%'>F10 Date</td><td width='33%'>Missed</td></tr>\r\n";
html += "</table>";
html += "<table border='1' width='100%'>\r\n";
foreach (DataRow dr in ds.F10Visits.Rows)
{
if (dr["NickName"] == pDr["NickName"])
{
string line = "<td width='33%'>\r\n";
bool bol = (bool)dr["MissedDate"];
if (bol)
line = "<td width='33%' style='color:red'>\r\n";
html += "<tr>" + line;
html += dr["NickName"].ToString();
html += "</td>\r\n";
html += line;
html += dr["F10Date"].ToString();
html += "</td>\r\n";
html += line;
html += dr["MissedDate"].ToString();
html += "</td></tr>";
}
}
html += "</table>\r\n";
}
html += HtmlBottom;
var stream = f.OpenWrite();
byte[] buffer = System.Text.ASCIIEncoding.ASCII.GetBytes(html);
stream.Write(buffer, 0, buffer.Length);
stream.Close();
stream.Dispose();
ds.F10Visits.WriteXml(xmlData.FullName);
return link;
}
public async Task InspectAsync(IRVisClient rVisClient)
{
if (_pathToContainingDirectory.IsntAString())
{
SetUpStaging();
}
RequireDirectory(_pathToContainingDirectory);
var pathToCode = Combine(_pathToContainingDirectory, _codeFileName);
await rVisClient.ClearAsync();
var inspection = await rVisClient.InspectSymbolsAsync(pathToCode);
SymbolInfos = inspection.ToArr();
UnaryFunctions = SymbolInfos
.Filter(si =>
si.Level == 0 &&
si.Symbol.IsAString() &&
si.SymbolType == SymbolType.Function &&
si.Length == 1)
.OrderBy(si => si.Symbol)
.ToArr();
Scalars = SymbolInfos
.Filter(si =>
si.Level == 0 &&
si.Symbol.IsAString() &&
si.SymbolType == SymbolType.Vector &&
si.Length == 1 &&
si.Scalar.HasValue)
.OrderBy(si => si.Symbol)
.ToArr();
ScalarSets = SymbolInfos
.Filter(si =>
si.Level == 0 &&
si.Symbol.IsAString() &&
(si.SymbolType == SymbolType.Vector || si.SymbolType == SymbolType.List) &&
si.Names?.Length > 1 &&
si.Value?.NRows == 1)
.OrderBy(si => si.Symbol)
.ToArr();
DataSets = SymbolInfos
.Filter(si =>
si.Level == 0 &&
si.Value?.ColumnNames.All(cn => cn.IsAString()) == true &&
si.Value?.NRows > 1)
.OrderBy(si => si.Symbol)
.ToArr();
ParameterCandidates = Scalars.Map(s => new ParameterCandidate(s));
ValueCandidates = DataSets.Map(ds => new ValueCandidate(ds, SymbolInfos));
}
public optionActionType(DataSets.dsModuleStructure3 dsModuleStructure)
: this()
{
dsModuleStructureGUI = dsModuleStructure;
bs_bbt_action_type.DataSource = dsModuleStructureGUI;
if (this.dsModuleStructureGUI.dtActionType.Count == 0)
{
ta_bbt_action_type.Fill(this.dsModuleStructureGUI.dtActionType);
}
}
public Report(String name, DataSets dataSets, Body body,
PageHeader pageHeader, PageFooter pageFooter, Boolean displayTitle)
{
Name = name;
DataSets = dataSets;
Body = body;
PageHeader = pageHeader;
PageFooter = pageFooter;
DisplayTitle = displayTitle;
}
public void LoadData()
{
string jsonString = File.ReadAllText(Application.dataPath + "/Resources/GameplayData.json");
dataSets = new DataSets();
JsonUtility.FromJsonOverwrite(jsonString, dataSets);
dataRange.dataSets = dataSets;
dataRange.SetZ(dataSets.DataSetList.Length);
dataRange.GenerateGraph();
}
public optionModuleType(DataSets.dsModuleStructure2 dsModuleStructure)
: this()
{
dsModuleStructureGUI = dsModuleStructure;
bsModuleType.DataSource = dsModuleStructureGUI;
if (this.dsModuleStructureGUI.dtModuleType.Count == 0)
{
taModuleType.Fill(this.dsModuleStructureGUI.dtModuleType);
}
}
public optionLabwareParameterType(DataSets.dsModuleStructure2 dsModuleStructure)
: this()
{
dsModuleStructureGUI = dsModuleStructure;
bsLabwareParameterType.DataSource = dsModuleStructureGUI;
if (this.dsModuleStructureGUI.dtModuleType.Count == 0)
{
taLabwareParameterType.Fill(this.dsModuleStructureGUI.dtLabwareParameterType);
}
}
/// <summary>
/// Asynchronously retrieve number of data sets matching query.
/// </summary>
/// <param name="query">The query filter to use</param>
/// <param name="token">Optional cancellation token</param>
/// <returns>Number of data sets matching given filters</returns>
public async Task <int> AggregateAsync(DataSetQuery query, CancellationToken token = default)
{
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
var req = DataSets.aggregate(query);
return(await RunAsync(req, token).ConfigureAwait(false));
}
/// <summary>
/// Asynchronously retrieve a list of data set like objects matching the given filter.
/// </summary>
/// <typeparam name="T">Type of data set to return, e.g. DataSet or DataSetWithoutMetadata.</typeparam>
/// <param name="query">The query filter to use.</param>
/// <param name="token">Optional cancellation token to use.</param>
/// <returns>List of data sets matching given filters and optional cursor</returns>
public async Task <IItemsWithCursor <T> > ListAsync <T>(DataSetQuery query, CancellationToken token = default) where T : DataSet
{
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
var req = DataSets.list <T>(query);
return(await RunAsync(req, token).ConfigureAwait(false));
}
/// <summary>
/// Asynchronously create data sets.
/// </summary>
/// <param name="dataSets">Data sets to create.</param>
/// <param name="token">Optional cancellation token.</param>
/// <returns>Sequence of created dataSets.</returns>
public async Task <IEnumerable <DataSet> > CreateAsync(IEnumerable <DataSetCreate> dataSets, CancellationToken token = default)
{
if (dataSets is null)
{
throw new ArgumentNullException(nameof(dataSets));
}
var req = DataSets.create(dataSets);
return(await RunAsync(req, token).ConfigureAwait(false));
}
/// <summary>
/// Asynchronously retrieves information about multiple data set like objects in the same project. A maximum of
/// 1000 data set IDs may be listed per request and all of them must be unique.
/// </summary>
/// <param name="ids">The list of data set identities to retrieve.</param>
/// <param name="ignoreUnknownIds">Ignore IDs and external IDs that are not found. Default: false</param>
/// <typeparam name="T">Type of data set to return, e.g DataSet or DataSetWithoutMetadata.</typeparam>
/// <param name="token">Optional cancellation token.</param>
/// <returns>A sequence of the requested data sets.</returns>
public async Task <IEnumerable <T> > RetrieveAsync <T>(IEnumerable <Identity> ids, bool?ignoreUnknownIds = null, CancellationToken token = default) where T : DataSet
{
if (ids is null)
{
throw new ArgumentNullException(nameof(ids));
}
var req = DataSets.retrieve <T>(ids, ignoreUnknownIds);
return(await RunAsync(req, token).ConfigureAwait(false));
}
public optionSavedProtocol(DataSets.dsModuleStructure3 dsModuleStructure)
: this()
{
this.dsModuleStructureGUI = dsModuleStructure;
this.dtSavedProtocolBindingSource.DataSource = dsModuleStructureGUI;
this.dataGridView1.DataSource = taSavedProtocol1.GetDataByDesc();
this.dataGridView2.DataSource = taSavedProtocol1.GetData();
bindingSource1.DataSource = dataGridView2.DataSource;
this.bindingSource1.Filter = "description = null";
}
/// <summary>
/// Asynchronously update one or more data sets. Supports partial updates, meaning that fields omitted from the
/// requests are not changed
/// </summary>
/// <param name="query">The list of data sets to update.</param>
/// <param name="token">Optional cancellation token.</param>
/// <returns>Sequence of updated data sets.</returns>
public async Task <IEnumerable <DataSet> > UpdateAsync(IEnumerable <DataSetUpdateItem> query, CancellationToken token = default)
{
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
var req = DataSets.update <DataSet>(query);
var ret = await RunAsync(req, token).ConfigureAwait(false);
return(ret);
}
public void clearTable(DataSets ds, string tableName)
{
try
{
m_writeSems[ds].WaitOne();
m_dataSets[ds].Tables[tableName].Clear();
}
finally
{
m_writeSems[ds].Release();
}
}
public void removeTable(DataSets ds, string tableName)
{
try
{
m_writeSems[ds].WaitOne();
m_dataSets[ds].Tables.Remove(tableName);
}
finally
{
m_writeSems[ds].Release();
}
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs)
{
DataSets ds = new DataSets();
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);
}
public optionModuleTypeActionType(DataSets.dsModuleStructure3 dsModuleStructure)
: this()
{
this.dsModuleStructureGUI = dsModuleStructure;
bsModuleType.DataSource = dsModuleStructureGUI.dtModuleType;
bsActionType.DataSource = dsModuleStructureGUI.dtActionType;
bsModuleTypeActionType.DataSource = dsModuleStructureGUI.dtModuleTypeActionType;
bsActionValueType.DataSource = dsModuleStructureGUI.dtActionValueType;
bsModuleTypeActionType.MoveFirst();
updateActionTypeGrid();
bsModuleType.CurrentChanged += bsModuleType_CurrentChanged;
}
public void updateSavedProtocolRow(DataSets.dsModuleStructure3.dtSavedProtocolRow updateRow)
{
try
{
taSavedProtocol1.Update(updateRow);
}
catch (Exception ex)
{
MessageBox.Show("Invalid action type, try again !",
"Error !",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
dsModuleStructureGUI.RejectChanges();
}
}
public void updateRow(DataSets.dsModuleStructure2.dtLabwareParameterTypeRow updateRow)
{
try
{
taLabwareParameterType.Update(updateRow);
}
catch (Exception ex)
{
MessageBox.Show("Invalid action type, try again !",
"Error !",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
dsModuleStructureGUI.RejectChanges();
}
}
public void initControl(DataSets.dsModuleStructure3 dsModuleStructure, BindingSource bsModule)
{
this.dsModuleStructure = dsModuleStructure;
this.bsModule = bsModule;
bsModule.DataSource = this.dsModuleStructure;
bsModuleType.DataSource = this.dsModuleStructure;
this.dataGridView1.DataSource = this.bsModule;
this.bsModule.DataMember = "dtModule";
this.bsModule.DataSource = this.dsModuleStructure;
initData();
//_dsModuleStructure.dtModule.dtModuleRowChanged += dtModule_dtModuleRowChanged;
}
public void updateRow(DataSets.dsModuleStructure3.dtActionValueTypeRow updateRow)
{
try
{
ta_bbt_action_value_type.Update(updateRow);
}
catch (Exception ex)
{
MessageBox.Show("Invalid action type, try again !",
"Error !",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
dsModuleStructureGUI.RejectChanges();
}
}
public StepCompositeNode(DataSets.dsModuleStructure2.dtStepCompositeRow stepCompositeRow)
{
if(stepCompositeRow == null)
{
return;
}
if(stepCompositeRow.pk_id < 0)
{
//return;
}
_stepCompositeRow = stepCompositeRow;
this.Text = stepCompositeRow.description;
this.BackColor = Color.Yellow;
}
public StepLeafNode(DataSets.dsModuleStructure2.dtStepLeafRow stepLeaf)
{
if(stepLeaf == null)
{
return;
}
if(stepLeaf.pk_id < 0)
{
//return;
}
_stepLeaf = stepLeaf;
this.Text = stepLeaf.description;
this.BackColor = Color.LightBlue;
}
public void executeAction(DataSets.dsModuleStructure3.dtActionValueRow row)
{
if (row.dtActionTypeRow.pk_id == PIPETTE)
{
Int16 volume = 0;
if (Int16.TryParse(row.description, out volume))
{
MultiChannelPipette.pipette(volume);
wait.Reset();
wait.WaitOne();
Int16 delay = Convert.ToInt16(row.description);
System.Threading.Thread.Sleep(delay / 2);
}
}
else if (row.dtActionTypeRow.pk_id == DISPENSE)
{
Int16 volume = 0;
if (Int16.TryParse(row.description, out volume))
{
MultiChannelPipette.dispense(volume);
wait.Reset();
wait.WaitOne();
Int16 delay = Convert.ToInt16(row.description);
System.Threading.Thread.Sleep(delay / 2);
}
}
else if (row.dtActionTypeRow.pk_id == MOVE_Z2)
{
Int16 tempValue = 0;
if (Int16.TryParse(row.description, out tempValue))
{
MultiChannelPipette.sendPositionToMoveTo(tempValue);
wait.Reset();
wait.WaitOne();
}
}
else if (row.dtActionTypeRow.pk_id == HOME)
{
MultiChannelPipette.homeTool();
wait.Reset();
wait.WaitOne();
}
}
public void executeAction(DataSets.dsModuleStructure3.dtActionValueRow action)
{
int moduleTypeId = action.dtStepLeafRow.dtStepCompositeRow.dtModuleRow.dtModuleTypeRow.pk_id;
if (moduleTypeId == TOOL_HOLDER)
{
movement.move(action);
}
else if(moduleTypeId == PINCE)
{
pince.executeAction(action);
}
else if(moduleTypeId == SNGLE_CHANNEL_PIPETTE)
{
singleChannePipette.executeAction(action);
}
else if (moduleTypeId == MULTI_CHANNEL_PIPETTE)
{
multiChannelPipette.executeAction(action);
}
}
public void addNodes(DataSets.dsModuleStructure2.dtStepCompositeRow row, TreeNode parentNode)
{
TreeNode treeNode = new StepCompositeNode(row);
if(parentNode == null)
{
tlvSteps.Nodes.Add(treeNode);
}
else
{
parentNode.Nodes.Add(treeNode);
}
foreach (DataSets.dsModuleStructure2.dtStepCompositeRow childRows in row.GetdtStepCompositeRows())
{
addNodes(childRows, treeNode);
}
foreach (DataSets.dsModuleStructure2.dtStepLeafRow stepLeafRow in row.GetdtStepLeafRows())
{
TreeNode stepLeafNode = new StepLeafNode(stepLeafRow);
treeNode.Nodes.Add(stepLeafNode);
}
}
public void addStepCompositeNode(DataSets.dsModuleStructure2.dtStepCompositeRow stepCompositeRow)
{
SelectedNode.Nodes.Add(new StepCompositeNode(stepCompositeRow));
}
public void initControl(DataSets.dsModuleStructure3 dsModuleStructure, BindingSource bsModuleType)
{
_dsModuleStructure = dsModuleStructure;
_bsModuleType = bsModuleType;
_bsModuleType.CurrentChanged += _bsModuleType_CurrentChanged;
initTree();
}
public void updateRow(DataSets.dsModuleStructure3.dtStepLeafRow updateRow)
{
try
{
taStepLeaf.Update(updateRow);
}
catch (Exception ex)
{
MessageBox.Show("Invalid step composite row, try again !",
"Error !",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
_dsModuleStructure.RejectChanges();
}
}
public void setSelectedModule(DataSets.dsModuleStructure3.dtModuleTypeRow moduleTypeRow, DataSets.dsModuleStructure3.dtActionTypeDataTable dtActionType)
{
btnAdd.Enabled = (!String.IsNullOrEmpty(moduleTypeRow.description) && dtActionType.Rows.Count > 0);
btnDelete.Enabled = (!String.IsNullOrEmpty(moduleTypeRow.description) && dtActionType.Rows.Count > 0);
//_contextMenuAutoFill.Items[STEP_TYPE].Enabled = (!String.IsNullOrEmpty(moduleTypeRow.Description) && dtActionType.Rows.Count > 0);
}
public void setDataSet(DataSets.dsModuleStructure3 dsModuleStructure)
{
this.dsModuleStructure = dsModuleStructure;
}
public ReportViewer(DataSets.SinglePlayerHistory ds)
{
InitializeComponent();
this.webBrowser1.Url = GetReportDocument(ds);
}
private Document GetDocument(DataSets.Order.CalculatedOrdersRow row,
DataSets.Order.CalculatedOrderDetailsDataTable detailDataTable,
DataSets.Order.DeletedOrderDetailsDataTable deletedOrderDetailsDataTable,
Token lastToken, NorthwindConfig config)
{
#region Declarations
OrderDocument doc;
string id;
LogState logState = LogState.Updated;
Document lineItemDoc;
CountryCodes countryCodes = new CountryCodes();
#endregion
id = row.OrderID.ToString();
if (lastToken.InitRequest)
logState = LogState.Created;
else if (row.IsCreateIDNull() || row.IsModifyIDNull()
|| row.IsCreateUserNull() || row.IsModifyUserNull())
logState = LogState.Created;
else if ((row.CreateID > lastToken.SequenceNumber)
&& (row.CreateUser != config.CrmUser))
logState = LogState.Created;
else if ((row.CreateID == lastToken.SequenceNumber)
&& (row.CreateUser != config.CrmUser)
&& (id.CompareTo(lastToken.Id.Id) > 0))
logState = LogState.Created;
else if ((row.ModifyID >= lastToken.SequenceNumber) && (row.ModifyUser != config.CrmUser))
logState = LogState.Updated;
doc = new OrderDocument();
doc.Id = id;
doc.LogState = logState;
doc.currency.Value = config.CurrencyCode;
doc.pricinglistid.Value = Constants.DefaultValues.PriceList.ID;
doc.reference.Value = id;
if (row.IsCustomerIDNull())
doc.accountid.Value = null;
else
doc.accountid.Value = Constants.CustomerIdPrefix + row.CustomerID;
if (row.IsOrderDateNull())
doc.opened.Value = null;
else
doc.opened.Value = row.OrderDate;
if (row.IsShippedDateNull())
doc.status.Value = Constants.OrderStatus.Active;
else
doc.status.Value = Constants.OrderStatus.Completed;
//doc.DiscountPercentage.Value = new decimal(0);
//doc.grossamt.Value = row.IsTotalQuotedPriceNull() ? new decimal(0) : Convert.ToDecimal(row.TotalQuotedPrice);
doc.discountamt.Value = new decimal(0);
doc.lineitemdisc.Value = row.IsDiscountAmountNull() ? new decimal(0) : Convert.ToDecimal(row.DiscountAmount);
doc.nettamt.Value = row.IsTotalNetPriceNull() ? new decimal(0) : Convert.ToDecimal(row.TotalNetPrice);
doc.freight.Value = row.IsFreightNull() ? new decimal(0) : row.Freight;
doc.tax.Value = new decimal(0);
doc.grossamt.Value = doc.nettamt.Value;
if (row.IsRequiredDateNull())
doc.deliverydate.Value = null;
else
doc.deliverydate.Value = row.RequiredDate;
if (row.IsEmployeeIDNull())
doc.salesrepr.Value = null;
else
doc.salesrepr.Value = Convert.ToString(row.EmployeeID);
if (row.IsShipViaNull())
doc.shippedvia.Value = null;
else
doc.shippedvia.Value = row.ShipVia;
OrderAddress orderAddress = new OrderAddress();
orderAddress.SetNorthwindAddress(row.IsShipAddressNull() ? "" : row.ShipAddress,
row.IsShipCityNull() ? "" : row.ShipCity,
row.IsShipPostalCodeNull() ? "" : row.ShipPostalCode,
row.IsShipCountryNull() ? "" : row.ShipCountry);
doc.shipaddress.Value = orderAddress.CrmOrderAddress;
foreach (DataSets.Order.CalculatedOrderDetailsRow detailRow in detailDataTable.Rows)
{
lineItemDoc = GetDocumentLineItem(detailRow, lastToken, config);
if ((doc.LogState != LogState.Created) && (lineItemDoc.HasNoLogStatus))
continue;
doc.orderitems.Add(lineItemDoc);
}
foreach (DataSets.Order.DeletedOrderDetailsRow deletedRow in deletedOrderDetailsDataTable.Rows)
{
lineItemDoc = new LineItemDocument();
lineItemDoc.Id = deletedRow[0].ToString();
lineItemDoc.LogState = LogState.Deleted;
doc.orderitems.Add(lineItemDoc);
}
return doc;
}
private Document GetDocumentLineItem(DataSets.Order.CalculatedOrderDetailsRow row, Token lastToken, NorthwindConfig config)
{
#region Declarations
LineItemDocument doc;
string id;
decimal discountPercentage;
#endregion
id = row.OrderID.ToString() + "-" + row.ProductID.ToString();
doc = new LineItemDocument();
doc.Id = id;
if (lastToken.InitRequest)
doc.LogState = LogState.Created;
else if ((row.CreateID >= lastToken.SequenceNumber) && (row.CreateUser != config.CrmUser))
doc.LogState = LogState.Created;
else if ((row.ModifyID >= lastToken.SequenceNumber) && (row.ModifyUser != config.CrmUser))
doc.LogState = LogState.Updated;
doc.productid.Value = row.ProductID;
//doc.orderquouteid.Value = row.OrderID;
doc.uomid.Value = row.ProductID;
doc.quantity.Value = row.IsQuantityNull() ? Convert.ToInt16(0) : row.Quantity;
doc.listprice.Value = row.IsUnitPriceNull() ? new decimal(0) : row.UnitPrice;
discountPercentage = row.IsDiscountNull() ? (decimal)0 : Convert.ToDecimal(row.Discount);
//doc.discountsum.Value = (decimal)(short)doc.Quantity.Value * (decimal)doc.ListPrice.Value * discountPercentage;
doc.discountsum.Value = (decimal)doc.listprice.Value * discountPercentage;
doc.quotedprice.Value = (decimal)doc.listprice.Value * (1 - discountPercentage);
//doc.quotedprice.Value = row.IsQuotePriceNull() ? new decimal(0) : Convert.ToDecimal(row.QuotePrice);
doc.taxrate.Value = "0";
doc.tax.Value = new decimal(0);
doc.quotedpricetotal.Value = Convert.ToDecimal(doc.quantity.Value) * Convert.ToDecimal(doc.quotedprice.Value);
return doc;
}
public ParameterActions(DataSets.dsModuleStructure3.dtActionTypeRow parameterActionType)
: this()
{
this._parameterActionType = parameterActionType;
txtParameterKey.Text = _parameterActionType.description;
}
