public ListJson <DBItem> ExecuteRead(IDbCommand command, Tabloid tabloid)
{
using (DBReader reader = ExecuteCommand(command))
{
ListJson <DBItem> result = Read(reader, tabloid);
return(result);
}
}
/// <summary>
/// Updates the <see cref="SecurePlayerPrefs"/> with the new values of the <see cref="SecurePlayerPrefList"/>.
/// </summary>
private void UpdatePlayerPrefs()
{
ListJson array = new ListJson(itemList.ToArray());
SerializedList = JsonUtils.Serialize(array);
SecurePlayerPrefs.SetString(GetFullKeyName(), SerializedList);
}
public ListJson <DBItem> Read(DBReader reader, Tabloid tabloid)
{
ListJson <DBItem> items = new ListJson <DBItem>();
while (reader.Read())
{
DBItem newItem = new DBItem(this, tabloid);
for (int i = 0; i < reader.FieldCount; i++)
{
string columnName = reader.GetName(i);
newItem[columnName] = reader[columnName];
}
items.Add(newItem);
}
return(items);
}
protected override ListJson <DBItem> Read(SqlDataReader reader)
{
ListJson <DBItem> items = new ListJson <DBItem>();
while (reader.Read())
{
DBItem newItem = new DBItem();
for (int i = 0; i < reader.FieldCount; i++)
{
string columnName = reader.GetName(i);
// sloupec, kt. není součástí tabulky (as, count, ...)
DBColumn column = tabloid.columns.SingleOrDefault(x => x.Name == columnName);
int columnId = column != null ? column.ColumnId : -1;
newItem.createProperty(columnId, columnName, reader[columnName]);
}
items.Add(newItem);
}
return(items);
}
public override void InnerRun(Dictionary <string, object> vars, Dictionary <string, object> outputVars, Dictionary <string, object> InvertedInputVars, Message message)
{
// init
COREobject core = COREobject.i;
DBConnection db = core.Entitron;
string tableName = vars.ContainsKey("TableName") ? (string)vars["TableName"] : (string)vars["__TableName__"];
bool searchInShared = vars.ContainsKey("SearchInShared") ? (bool)vars["SearchInShared"] : false;
string orderBy = vars.ContainsKey("OrderBy") ? (string)vars["OrderBy"] : null;
bool isDescending = vars.ContainsKey("Descending") ? (bool)vars["Descending"] : false;
ListJson <DBItem> columns = db.ExecuteRead(db.CommandSet.LIST_column(db, tableName), new DBTable(db)
{
Name = tableName
});
//
var delete = db.Table(tableName).Delete();
int CondCount = vars.Keys.Where(k => k.StartsWith("CondColumn[") && k.EndsWith("]")).Count();
// setConditions
for (int i = 0; i < CondCount; i++)
{
string condOperator = vars.ContainsKey($"CondOperator[{i}]") ? (string)vars[$"CondOperator[{i}]"] : "Equal";
string condColumn = (string)vars[$"CondColumn[{i}]"];
object condValue = vars[$"CondValue[{i}]"];
DBItem column = columns.Single(c => (string)c["name"] == condColumn);
object value = condOperator != "IsIn"
? DataType.ConvertTo(DataType.FromDBName((string)column["typeName"], db.Type), condValue)
: column["typeName"];
switch (condOperator)
{
case "Less":
delete.Where(c => c.Column(condColumn).Less(value));
break;
case "LessOrEqual":
delete.Where(c => c.Column(condColumn).LessOrEqual(value));
break;
case "Greater":
delete.Where(c => c.Column(condColumn).Greater(value));
break;
case "GreaterOrEqual":
delete.Where(c => c.Column(condColumn).GreaterOrEqual(value));
break;
case "Equal":
delete.Where(c => c.Column(condColumn).Equal(value));
break;
case "IsIn":
// string, multiple values
if ((condValue is string) && ((string)condValue).Contains(","))
{
delete.Where(c => c.Column(condColumn).In((condValue as string).Split(',')));
}
// Enumerable
else
{
delete.Where(c => c.Column(condColumn).In((IEnumerable <object>)condValue));
}
break;
default: // ==
delete.Where(c => c.Column(condColumn).Equal(value));
break;
}
}
// order
delete.Run();
}
public static JToken DataTableResponse(COREobject core, List <DBItem> Data, int BootstrapPageId, string Columns, string Search, string Order, int draw, int start = -1, int length = -1)
{
// Init
DBEntities context = core.Context;
List <DBItem> ds = new List <DBItem>();
string orderColumnName = null;
if (Data.Count() > 0)
{
/**********************************************************************************/
/* Vytvoříme si datasource - všechny sloupce jako string, přidáme hiddenId a akce */
/**********************************************************************************/
// Musíme znovu vytvořit sloupec s akcema
string actionIcons = "";
MozaicBootstrapComponent uic = context.MozaicBootstrapComponents.Where(c => c.ElmId == core.Executor && c.MozaicBootstrapPageId == BootstrapPageId).FirstOrDefault();
if (uic != null)
{
JToken attributes = JToken.Parse(uic.Attributes);
foreach (JToken attr in attributes)
{
if ((string)attr["name"] == "data-actions")
{
string actionsString = ((string)attr["value"]).Replace('\'', '"');
JToken actions = JToken.Parse(actionsString);
List <string> actionsIconsList = new List <string>();
foreach (JToken a in actions)
{
actionsIconsList.Add($"<i title=\"{(string)a["title"]}\" class=\"{(string)a["icon"]}\" data-action=\"{(string)a["action"]}\" data-idparam=\"{(string)a["idParam"]}\" data-confirm=\"{(string)a["confirm"]}\"></i>");
}
if (actionsIconsList.Count() > 0)
{
actionIcons = "<span class=\"text-nowrap\">" + string.Join(" ", actionsIconsList) + "</span>";
}
break;
}
}
}
List <string> displayNames = new List <string>();
List <string> columnsNames = Data[0].getColumnNames();
try
{
displayNames = Data[0].getColumnDisplayNames().ToList();
}
catch (NullReferenceException)
{
displayNames = columnsNames;
}
foreach (DBItem row in Data)
{
DBItem newRow = new DBItem(null, null);
int i = 0;
foreach (string prop in columnsNames)
{
var value = row[prop];
var displayName = displayNames[columnsNames.IndexOf(prop)];
if (i == 0)
{
orderColumnName = displayName;
}
// Převedeme všechny hodnoty na string
if (value is bool)
{
newRow[displayName] = (bool)value ? "Ano" : "Ne";
}
else if (value is DateTime)
{
newRow[displayName] = ((DateTime)value).ToString("d. M. yyyy H:mm:ss");
}
else if (value is string)
{
newRow[displayName] = (string)value;
}
else
{
newRow[displayName] = value.ToString();
}
// pokud je sloupec id nebo Id nastavíme hiddenId
if (prop == "id" || prop == "Id")
{
i++;
newRow["hiddenId"] = value.ToString();
}
i++;
}
// Pokud existují akce, přidáme je
if (!string.IsNullOrEmpty(actionIcons))
{
newRow["Akce"] = actionIcons;
}
ds.Add(newRow);
}
}
/**********************************************************************************/
/* Filtr dat */
/**********************************************************************************/
List <DBItem> filteredData = new List <DBItem>();
JToken columnsSearch = JToken.Parse(Columns);
JToken search = JToken.Parse(Search);
filteredData.AddRange(ds);
foreach (JToken cs in JToken.Parse(Columns))
{
string searchFor = (string)cs["search"]["value"];
if (!string.IsNullOrEmpty(searchFor))
{
string columnName = (string)cs["data"];
filteredData = filteredData.Where(r => ((string)r[columnName]).ToLowerInvariant().Contains(searchFor.ToLowerInvariant())).ToList();
}
}
string globalSearchFor = (string)search["value"];
if (!string.IsNullOrEmpty(globalSearchFor))
{
filteredData.Clear();
foreach (DBItem row in ds)
{
foreach (string prop in row.getColumnNames())
{
if (prop == "id" || prop == "Id" || prop == "hiddenId" || prop == "Akce")
{
continue;
}
List <DBItem> found = ds.Where(r => ((string)r[prop]).ToLowerInvariant().Contains(globalSearchFor.ToLowerInvariant())).ToList();
if (found.Count() > 0)
{
foreach (DBItem item in found)
{
if (!filteredData.Contains(item))
{
filteredData.Add(item);
}
}
}
}
}
}
/**********************************************************************************/
/* Zpracujeme řazení */
/**********************************************************************************/
JToken order = JToken.Parse(Order);
int j = 0;
IOrderedEnumerable <DBItem> tmpData = filteredData.OrderBy(r => r[r.getColumnNames().First()]);
var comparer = new NaturalComparer <string>(CompareNatural);
foreach (JToken by in order)
{
string columnName = (string)columnsSearch[(int)by["column"]]["data"];
string dir = (string)by["dir"];
if (j == 0)
{
tmpData = dir == "desc" ?
filteredData.OrderByDescending(r => (string)r[columnName], comparer) :
filteredData.OrderBy(r => (string)r[columnName], comparer);
}
else
{
tmpData = dir == "desc" ?
tmpData.ThenByDescending(r => (string)r[columnName], comparer) :
tmpData.ThenBy(r => (string)r[columnName], comparer);
}
j++;
}
filteredData = tmpData.ToList();
/**********************************************************************************/
/* Zpracujeme stránkování */
/**********************************************************************************/
var pagedData = length == -1 ? filteredData.ToList() : filteredData.Skip(start).Take(length).ToList();
/**********************************************************************************/
/* Vrátíme výsledek */
/**********************************************************************************/
ListJson <DBItem> finalDS = new ListJson <DBItem>();
finalDS.AddRange(pagedData);
JToken response = new JObject();
response["draw"] = draw;
response["recordsTotal"] = Data.Count();
response["recordsFiltered"] = filteredData.Count();
response["data"] = finalDS.ToJson();
return(response);
}
