public void ThenIValidateThatTheResponseBodyContainsTheFollowingValues(Table table)
{
var dictionary = TableUtils.ConvertToDictionary(table);
var fieldsMapped = Mapper.MapValues(dictionary, helper.GetData());
AssertUtils.AssertExpectedValues(response, fieldsMapped);
}
private List <string> ApplyWhereConditions(List <string> unfilteredRecords, string tableName)
{
var records = new List <string>();
var groupedConditions = new List <KeyValuePair <string, List <string> > >();
foreach (var condition in WhereConditionsList)
{
if (groupedConditions.Find(elem => elem.Key == condition.Item1.Item2).Value == null)
{
groupedConditions.Add(new KeyValuePair <string, List <string> >(condition.Item1.Item2, new List <string>()));
}
groupedConditions.Find(elem => elem.Key == condition.Item1.Item2).Value.Add(condition.Item2);
}
var tableStructure = TableUtils.GetTableColumns(DatabaseName, tableName);
foreach (var record in unfilteredRecords)
{
if (RecordMatchesCondition(record, tableStructure, groupedConditions))
{
records.Add(record);
}
}
return(records);
}
public void TestMethod1()
{
string[] header = { "et", "to", "tre" };
var wtu = new TableUtils(header);
Assert.IsTrue(wtu.Columns[0].Name == "et");
}
private List <string> ApplyProjection(List <string> records)
{
var outputColumns = new List <string>();
var tableStructure = TableUtils.GetTableColumns(DatabaseName, TableName);
if (AggregateFunctionList.Count == 0)
{
// Select the values of the columns from the record and add them to the output
foreach (var record in records)
{
var outputRecord = "";
var recordSplit = record.Split('#');
foreach (var output in OutputParamsAliasList)
{
outputRecord += recordSplit[tableStructure.IndexOf(output.Item1.Item2)] + "#";
}
// Apply DISTINCT as well
outputRecord = outputRecord.Remove(outputRecord.Length - 1);
if (!outputColumns.Contains(outputRecord))
{
outputColumns.Add(outputRecord);
}
}
}
else
{
// Collect the result of the aggregations => This will always be one row
}
return(outputColumns);
}
public async Task <Either <DomainError, Unit> > Delete(InterestedStorage subscription)
{
TableOperation deleteOperation = TableOperation.Delete(subscription.AddEtag());
var result = await TableUtils.TryExecute(() => _tableClient.ExecuteAsync(deleteOperation));
return(result.Map(x => unit));
}
private void CheckUniqueIndexConstraint(string record)
{
var columnValues = record.Split('#');
var mongoDB = new MongoDBAcess(DatabaseName);
var indexFiles = TableUtils.GetIndexFiles(DatabaseName, TableName);
foreach (var file in indexFiles)
{
if (file.IsUnique)
{
var createKeyOfUqIndex = "";
var pk = "";
for (int idx = 0; idx < ColumnsInfo.Count; idx++)
{
if (file.IndexColumns.Exists(elem => elem == ColumnsInfo[idx].ColumnName))
{
createKeyOfUqIndex += columnValues[idx] + '#';
}
if (ColumnsInfo[idx].PK)
{
pk = columnValues[idx] + "#";
}
}
createKeyOfUqIndex = createKeyOfUqIndex.Remove(createKeyOfUqIndex.Length - 1);
pk = pk.Remove(pk.Length - 1);
MongoDB.InsertKVIntoCollection(file.IndexFileName, createKeyOfUqIndex, pk);
}
}
}
public ActionResult Shooter()
{
string connstring = RouteConfig.connectString;
NpgsqlConnection connection = new NpgsqlConnection(connstring);
connection.Open();
NpgsqlCommand command = new NpgsqlCommand("SELECT * FROM shooters.shooter", connection);
NpgsqlDataReader dataReader = command.ExecuteReader();
NpgsqlDataAdapter da = new NpgsqlDataAdapter();
DataTable dt = new DataTable();
//for (int i = 0; dataReader.Read(); i++){}
while (dataReader.Read())
{
}
dt.Load(dataReader);
da.SelectCommand = command;
da.Fill(dt);
List <actor> _list = TableUtils.CreateListFromTable <actor>(dt);
connection.Close();
var model = new Shooters()
{
};
model.Actors = _list;
return(View(model));
// return View();
}
public ActionResult EditIncident(int iKey)
{
string query = "SELECT * FROM shooters.incitingIncident where iKey= '" + iKey + "'";
var _model = TableUtils.queryToObject <incitingIncident>(query);
return(View(_model));
}
public Task <Either <DomainError, IImmutableList <string> > > GetTitles()
{
var tableQuery = new TableQuery <TitlesStorage>();
return(TableUtils.TryExecuteSimpleQuery(() => _tableClient.ExecuteQuerySegmentedAsync(tableQuery, null))
.BindAsync(Mapper));
}
public void TestMethod1()
{
string[] header = { "et", "to", "tre" };
var wtu = new TableUtils(header);
StfAssert.StringEquals("Et", wtu.Columns[0].Name, "et");
}
private string CheckForPrimaryKey(List <Tuple <Tuple <string, string>, string> > conditionList)
{
if (conditionList.Count == 0)
{
return("");
}
var columnsUsed = "";
var primaryKeyColumns = TableUtils.GetPrimaryKey(DatabaseName, TableName);
var primaryKeyColumnsString = "";
foreach (var primaryKey in primaryKeyColumns)
{
primaryKeyColumnsString += primaryKey + "_";
}
primaryKeyColumnsString = primaryKeyColumnsString.Remove(primaryKeyColumnsString.Length - 1);
foreach (var column in conditionList)
{
columnsUsed += column.Item1.Item2 + "_";
}
if (columnsUsed != "")
{
columnsUsed = columnsUsed.Remove(columnsUsed.Length - 1);
if (primaryKeyColumnsString.Contains(columnsUsed))
{
// the primary key of the table can be used if the attributes are a prefix of the attributes in the primary key structure
return(columnsUsed);
}
}
return("");
}
public override IQueryable <PostDTO> Query()
{
var query = Context.Set <Post>().Where(item => item.UserId == _userId).ProjectTo <PostDTO>(_config);
query = TableUtils.ApplyDeletedFilter(query, IncludeDeleted);
return(query);
}
public async Task <Either <DomainError, IImmutableList <InterestedStorage> > > Get(Email userEmail)
{
var user = OptionUtils.UnpackOption(userEmail.Value, string.Empty);
var tableQuery = new TableQuery <InterestedStorage>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, user));
return(await TableUtils.TryGetAllTableElements(_tableClient, tableQuery));
}
private bool TryOpen(TableLineRef inRef)
{
UnityEngine.Object obj = inRef.TableSource as UnityEngine.Object;
if (obj == null)
{
return(false);
}
if (!TryEdit(obj))
{
return(false);
}
int ruleIdx = TableUtils.IndexOfRule(m_SelectionState.Table, inRef.RuleId);
if (ruleIdx >= 0)
{
SelectRule(ruleIdx);
if (inRef.ConditionIndex >= 0)
{
SelectCondition(inRef.ConditionIndex);
}
else if (inRef.ActionIndex >= 0)
{
SelectAction(inRef.ActionIndex);
}
}
m_SelectionState.Refresh();
return(true);
}
public async Task DeleteAllTest()
{
IEnumerable <TestTableEntity> rows = null;
IEnumerable <TestTableEntity> rowsAfterDelete = null;
using (var connection = new SqlConnection(Settings.ConnectionString))
{
await TableUtils.ClearTestDB(connection);
IEnumerable <object> list = new List <object>()
{
new { TestString = "HI", TestInt = 5 },
new { TestString = "HI2", TestInt = 6 },
new { TestString = "HI3", TestInt = 7 }
};
await connection.InsertMulti("TestTable", list);
rows = await connection.QueryAsync <TestTableEntity>("Select * from TestTable ORDER BY TestTableID;");
await connection.DeleteAll("TestTable");
rowsAfterDelete = await connection.QueryAsync <TestTableEntity>("Select * from TestTable ORDER BY TestTableID;");
}
Assert.AreEqual(3, rows.Count());
Assert.AreEqual(0, rowsAfterDelete.Count());
}
public ActionResult EditGunPurchase(int gpId = 9)
{
string query = "select * from shooters.gunPurchase where gpid = " + gpId;
gunPurchase gp = TableUtils.queryToObject <gunPurchase>(query);
return(View(gp));
}
public ActionResult ViewHealthDetails(string mName)
{
string query = "select * from shooters.massshootings where mName = '" + mName + "'";
massShooting ms = TableUtils.queryToObject <massShooting>(query);
return(View(ms));
}
public override IQueryable <TData> Query()
{
IQueryable <TData> query = this.Context.Set <TModel>().Project().To <TData>();
query = TableUtils.ApplyDeletedFilter(query, this.IncludeDeleted);
return(query);
}
public override IQueryable <TData> Query()
{
var query = Context.Set <TModel>().ProjectTo <TData>(_config);
query = TableUtils.ApplyDeletedFilter(query, IncludeDeleted);
return(query);
}
public void Table_utils_write_should_write_a_table2()
{
// Arrange
var(console, stdOut, _) = VirtualConsole.CreateBuffered(isOutputRedirected: false, isErrorRedirected: false);
// Act
TableUtils.Write(console,
_testData.GroupBy(x => x.Group),
new string[] { "Header0", "Header1", "Header2" },
null,
x => x.Integer.ToString(),
x => x.Str ?? string.Empty);
// Assert
string output = stdOut.GetString();
output.Should().NotBeNullOrWhiteSpace();
output.Should().ContainAll("Header0", "Header1",
"testA", "testB", "testC", "testD",
"0", "1", "2", "3", "4",
"X", "Z",
"X (2)", "Z (2)", "(1)");
output.Should().NotContainAll("Header2");
_output.WriteLine(output);
}
public async Task <Either <DomainError, InterestedStorage> > Merge(InterestedStorage subscription)
{
TableOperation insertOrMergeOperation = TableOperation.InsertOrMerge(subscription);
var result = await TableUtils.TryExecute(() => _tableClient.ExecuteAsync(insertOrMergeOperation));
return(result.Map(r => (InterestedStorage)r.Result));
}
public void TestTableCreate()
{
CrateDataReader reader = null;
List <Table> schemadata = null;
var tabledesc = (CrateTable)Attribute.GetCustomAttribute(typeof(CreatTestTable), typeof(CrateTable));
Assert.IsNotNull(tabledesc);
TableUtils.DropTable(tabledesc.Name);
using (var conn = TestCrateConnection())
{
conn.Open();
conn.CreateTable <CreatTestTable>();
var sql = "SELECT * FROM information_schema.tables WHERE table_name= '" + tabledesc.Name + "'";
using (var cmd = new CrateCommand(sql, conn))
{
reader = (CrateDataReader)cmd.ExecuteReader();
schemadata = reader.ToList <Table>();
}
}
Assert.IsNotNull(reader);
Assert.IsNotNull(schemadata);
Assert.Greater(schemadata.Count, 0);
Assert.AreEqual(EnumHelpers.Replication(tabledesc.NumberOfReplicas), schemadata[0].NumberOfReplicas);
Assert.AreEqual(tabledesc.NumberOfShards, schemadata[0].NumberOfShards);
}
public async Task DeleteByIDTest()
{
IEnumerable <TestTableEntity> rows = null;
IEnumerable <TestTableEntity> rowsAfterDelete = null;
using (var connection = new SqlConnection(Settings.ConnectionString))
{
await TableUtils.ClearTestDB(connection);
IEnumerable <object> list = new List <object>()
{
new { TestString = "HI", TestInt = 5 },
new { TestString = "HI2", TestInt = 6 },
new { TestString = "HI3", TestInt = 7 }
};
await connection.InsertMulti("TestTable", list);
rows = await connection.QueryAsync <TestTableEntity>("Select * from TestTable ORDER BY TestTableID;");
await connection.Delete("TestTable", new { TestTableID = rows.First().TestTableID });
rowsAfterDelete = await connection.QueryAsync <TestTableEntity>("Select * from TestTable ORDER BY TestTableID;");
}
Assert.AreEqual(3, rows.Count());
Assert.AreEqual(2, rowsAfterDelete.Count());
// Compare IDs to ensure proper entity was deleted.
Assert.AreEqual(rows.Skip(1).First().TestTableID, rowsAfterDelete.First().TestTableID);
Assert.AreEqual(rows.Skip(2).First().TestTableID, rowsAfterDelete.Skip(1).First().TestTableID);
}
public Task <Either <DomainError, IEnumerable <AnimeInfoWithImageStorage> > > GetBySeason(Season season, int year)
{
var partitionKey = IdHelpers.GenerateAnimePartitionKey(season, (ushort)year);
var tableQuery = new TableQuery <AnimeInfoWithImageStorage>().
Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey));
return(TableUtils.TryExecuteSimpleQuery(() => _tableClient.ExecuteQuerySegmentedAsync(tableQuery, null)));
}
public ActionResult Guns(string first, string last)
{
List <gun> _list = TableUtils.queryToTable <gun>("SELECT * FROM shooters.Gun");
Guns model = new Guns();
model._guns = _list;
return(View(model));
// return View();
}
private void OnGUI()
{
RegenContext();
SyncAllowedListOperations();
float width = this.position.width;
float thirdWidth = Mathf.Max(width / 3, 300) - EditorStyles.helpBox.padding.left;
using (new EditorGUILayout.HorizontalScope())
{
using (new EditorGUILayout.VerticalScope(GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true)))
{
GUILayout.Space(4);
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)))
{
RuleTableGUI();
GUILayout.FlexibleSpace();
}
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)))
{
ErrorGUI();
}
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)))
{
ConfigGUI();
}
GUILayout.Space(4);
}
EditorGUI.BeginChangeCheck();
{
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)))
{
RuleInfoGUI();
}
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)))
{
ConditionInfoGUI();
ActionInfoGUI();
}
}
if (EditorGUI.EndChangeCheck() && m_SelectionState.Rule != null && m_Context.Library != null)
{
RuleFlags flags = TableUtils.GetRuleFlags(m_SelectionState.Rule, m_Context.Library);
if (flags != m_SelectionState.Rule.Flags)
{
m_TargetState.UndoTarget.MarkDirty("Modified rule flags");
m_SelectionState.Rule.Flags = flags;
}
}
}
}
public ActionResult Shooter(string first, string last)
{
string query = "SELECT * FROM shooters.shooter";
List <actor> _actors = TableUtils.queryToTable <actor>(query);
Shooters _shooters = new Shooters();
_shooters.Actors = _actors;
return(View(_shooters));
}
private void RemoveFromFKIndexFiles(MongoDBAcess mongoDB)
{
ForeignKeyFiles.Clear();
ForeignKeyFiles = TableUtils.GetOwnForeignKeyFiles(DatabaseName, TableName);
foreach (var foreignKey in ForeignKeyFiles)
{
mongoDB.RemoveValueFromCollection(foreignKey, RemovedKey);
}
}
public ViewResult GunsNoType(int?page)
{
int pageSize = 10;
int pageNumber = (page ?? 1);
string query = "select * from shooters.gun where gname NOT in (select gName from shooters.gun natural join shooters.gunTypeRel)";
var _guns = TableUtils.queryToTable <gun>(query);
return(View(_guns.ToPagedList(pageNumber, pageSize)));
}
public ViewResult ShooterNoIncidents(int?page)
{
int pageSize = 10;
int pageNumber = (page ?? 1);
string query = "select * from shooters.shooter where first NOT IN (select first from shooters.incitingincident) AND last NOT IN (select last from shooters.incitingincident)";;
var _shooters = TableUtils.queryToTable <actor>(query);
return(View(_shooters.ToPagedList(pageNumber, pageSize)));
}
