/// <summary>
/// 新增|修改
/// </summary>
/// <param name="data"></param>
/// <param name="eventType"></param>
private void EditAdd(MySqlResponseData data, EnumTable eventType)
{
if (data.SubscribeData != null)
{
SubscribeDataModel formHtml = null;
SubscribeDataModel instanceID = data.SubscribeData.Where(c => c.Key.Equals("InstanceID")).FirstOrDefault();
SubscribeDataModel type = data.SubscribeData.Where(c => c.Key.Equals("Type")).FirstOrDefault();
SubscribeDataModel typeCode = data.SubscribeData.Where(c => c.Key.Equals("TypeCode")).FirstOrDefault();
switch (eventType)
{
case EnumTable.Insert:
formHtml = data.SubscribeData.Where(c => c.Key.Equals("Html")).FirstOrDefault();
break;
case EnumTable.Update:
formHtml = data.SubscribeData.Where(c => c.Key.Equals("Html") && c.Updated == true).FirstOrDefault();
break;
case EnumTable.Delete:
break;
default:
break;
}
if (formHtml != null && instanceID != null && type != null && typeCode != null)
{
new JiJiaWorkFlowRedis().HashSet <string>(RedisKey.ApplyFormKey(instanceID.Value), type.Value + "-" + typeCode.Value, formHtml.Value);
}
}
}
public void CreateSeqTest()
{
var t = EnumTable.Create <ESeq, object>();
Assert.IsNotNull(t);
var typeName = t.GetType().FullName;
Assert.IsTrue(typeName.Contains("RawTable"), "Expected RawTable, but was " + typeName);
}
public void CreateSparseTest()
{
var t = EnumTable.Create <ESparse, object>();
Assert.IsNotNull(t);
var typeName = t.GetType().FullName;
Assert.IsTrue(typeName.Contains("DictionaryTable"), "Expected DictionaryTable, but was " + typeName);
}
public void DeepCopySeqBoolTest()
{
var t = EnumTable.Create <ESeq, bool>();
t.SetAll(true);
Assert.IsTrue(t.All(x => x.Value));
var t2 = t.DeepCopy();
Assert.IsTrue(t2.All(x => x.Value));
}
public void IsValidKeySparseTest()
{
var t = EnumTable.Create <ESparse, object>();
foreach (var v in EnumHelper <ESparse> .Values)
{
Assert.IsTrue(t.IsValidKey(v));
}
Assert.IsFalse(t.IsValidKey((ESparse)(-999)));
}
public void IsValidKeySeqBoolTest()
{
var t = EnumTable.Create <ESeq, bool>();
foreach (var v in EnumHelper <ESeq> .Values)
{
Assert.IsTrue(t.IsValidKey(v));
}
Assert.IsFalse(t.IsValidKey((ESeq)(-999)));
}
public void DeepCopySparseTest()
{
var t = EnumTable.Create <ESparse, string>();
t.SetAll("hi");
Assert.IsTrue(t.All(x => x.Value == "hi"));
var t2 = t.DeepCopy();
Assert.IsTrue(t2.All(x => x.Value == "hi"));
}
public void DataAnalysis(MySqlResponseData data)
{
EnumTable eventType = (EnumTable)Enum.Parse(typeof(EnumTable), data.EventType);
SubscribeDataModel id = data.SubscribeData.Where(c => c.Key.Equals("ID")).FirstOrDefault();
if (id != null)
{
switch (eventType)
{
case EnumTable.Insert:
UpdateApplyCache(data.SubscribeData, id.Value);
break;
case EnumTable.Update:
//1流程结束，2流程退回,3流程提交失败
SubscribeDataModel updateStatus = data.SubscribeData.Where(c => c.Key.Equals("FlowApplyStatus") && c.Updated == true).FirstOrDefault();
if (updateStatus != null && id != null)
{
if (updateStatus != null)
{
int status = 0;
int.TryParse(updateStatus.Value, out status);
switch (status)
{
case 1:
case 2:
case 3:
DelCache(id.Value);
break;
default:
UpdateApplyCache(data.SubscribeData, id.Value);
break;
}
}
}
else
{
UpdateApplyCache(data.SubscribeData, id.Value);
}
break;
case EnumTable.Delete:
if (id != null)
{
DelCache(id.Value);
}
break;
default:
break;
}
}
}
public void SetAllAndClearSparseTest()
{
var t = EnumTable.Create <ESparse, string>();
Assert.IsTrue(t.All(x => x.Value == null));
t.SetAll("hi");
Assert.IsTrue(t.All(x => x.Value == "hi"));
t.Clear();
Assert.IsTrue(t.All(x => x.Value == null));
}
public void GetSetInvalidSparseTest()
{
var t = EnumTable.Create <ESparse, object>();
Assert.Throws <ArgumentOutOfRangeException>(() => t[(ESparse)(-999)] = 50);
#pragma warning disable 219
object x;
#pragma warning restore 219
Assert.Throws <ArgumentOutOfRangeException>(() => x = t[(ESparse)(-999)]);
}
public void GetSetInvalidSeqBoolTest()
{
var t = EnumTable.Create <ESeq, bool>();
Assert.Throws <ArgumentOutOfRangeException>(() => t[(ESeq)(-999)] = true);
#pragma warning disable 219
bool x;
#pragma warning restore 219
Assert.Throws <ArgumentOutOfRangeException>(() => x = t[(ESeq)(-999)]);
}
public void SetAllAndClearSeqBoolTest()
{
var t = EnumTable.Create <ESeq, bool>();
Assert.IsTrue(t.All(x => x.Value == default(bool)));
t.SetAll(true);
Assert.IsTrue(t.All(x => x.Value));
t.Clear();
Assert.IsTrue(t.All(x => x.Value == default(bool)));
}
public void AddDeclarations(IEnumerable <Declaration> aDeclarations)
{
foreach (var decl in aDeclarations)
{
if (DeclarationsToIgnore.Contains(decl.Name))
{
continue;
}
//== "sp_uint64" || decl.Name == "bool" || decl.Name == "byte") continue;
if (decl.Kind == "typedef")
{
StructCType structType = decl.CType as StructCType;
EnumCType enumType = decl.CType as EnumCType;
FunctionCType functionType = decl.CType as FunctionCType;
if (structType != null)
{
if (structType.Fields == null)
{
HandleTable.Add(decl.Name);
}
else
{
StructTable.Add(decl.Name, structType);
}
}
else if (enumType != null)
{
EnumTable.Add(decl.Name, enumType);
}
else if (functionType != null)
{
FunctionTypedefTable.Add(decl.Name, functionType);
}
}
else if (decl.Kind == "instance")
{
FunctionCType funcType = decl.CType as FunctionCType;
if (funcType == null)
{
continue;
}
FunctionTable.Add(decl.Name, funcType);
}
}
}
public void GetSetSeqBoolTest()
{
var t = EnumTable.Create <ESeq, bool>();
Assert.AreEqual(false, t[ESeq.a]);
t[ESeq.a] = true;
Assert.AreEqual(true, t[ESeq.a]);
t[ESeq.d] = true;
Assert.AreEqual(true, t[ESeq.d]);
t[ESeq.h] = false;
Assert.AreEqual(false, t[ESeq.h]);
t[ESeq.d] = true;
Assert.AreEqual(true, t[ESeq.d]);
}
public void GetSetSparseTest()
{
var t = EnumTable.Create <ESparse, object>();
Assert.AreEqual(null, t[ESparse.a]);
t[ESparse.a] = 5;
Assert.AreEqual(5, t[ESparse.a]);
t[ESparse.d] = 50;
Assert.AreEqual(50, t[ESparse.d]);
t[ESparse.h] = "hello";
Assert.AreEqual("hello", t[ESparse.h]);
t[ESparse.d] = 123;
Assert.AreEqual(123, t[ESparse.d]);
}
public void DataAnalysis(MySqlResponseData data)
{
EnumTable eventType = (EnumTable)Enum.Parse(typeof(EnumTable), data.EventType);
switch (eventType)
{
case EnumTable.Insert:
case EnumTable.Update:
EditAdd(data, eventType);
break;
case EnumTable.Delete:
break;
default:
break;
}
}
public void VerifyEnumWriteAndRead()
{
DropTable.For <EnumTable>().TryExecute(Connection);
CreateTable.For <EnumTable>().Execute(Connection);
var value = new EnumTable
{
Name = "Foo",
Something = Something.Second
};
InsertInto.Row(value).Execute(Connection);
var values = Select.From <EnumTable>().WhereEqual(x => x.Name, "Foo").ExecuteRead(Connection).ToList();
Assert.That(values, Has.Count.EqualTo(1));
Assert.That(values[0].Something, Is.EqualTo(Something.Second));
Assert.That(values[0].Name, Is.EqualTo("Foo"));
}
public void TryGetSetSparseTest()
{
var t = EnumTable.Create <ESparse, object>();
object o;
var r = t.TryGetValue(ESparse.a, out o);
Assert.IsTrue(r);
Assert.AreEqual(null, o);
r = t.TrySetValue(ESparse.a, "asdf");
Assert.IsTrue(r);
r = t.TryGetValue(ESparse.a, out o);
Assert.IsTrue(r);
Assert.AreEqual("asdf", o);
r = t.TryGetValue((ESparse)(-999), out o);
Assert.IsFalse(r);
r = t.TrySetValue((ESparse)(-999), "asdf");
Assert.IsFalse(r);
}
public void TryGetSetSeqBoolTest()
{
var t = EnumTable.Create <ESeq, bool>();
bool o;
var r = t.TryGetValue(ESeq.a, out o);
Assert.IsTrue(r);
Assert.AreEqual(false, o);
r = t.TrySetValue(ESeq.a, true);
Assert.IsTrue(r);
r = t.TryGetValue(ESeq.a, out o);
Assert.IsTrue(r);
Assert.AreEqual(true, o);
r = t.TryGetValue((ESeq)(-999), out o);
Assert.IsFalse(r);
r = t.TrySetValue((ESeq)(-999), true);
Assert.IsFalse(r);
}
public void EnumerateSparseTest()
{
var t = EnumTable.Create <ESparse, object>();
t[ESparse.c] = "hello";
foreach (var v in t)
{
if (v.Key == ESparse.c)
{
Assert.AreEqual("hello", v.Value);
}
else
{
Assert.AreEqual(null, v.Value);
}
}
var keys = t.Select(x => x.Key).ToArray();
var expectedKeys = EnumHelper <ESparse> .Values.ToArray();
Assert.AreEqual(keys.Length, expectedKeys.Length);
Assert.IsTrue(keys.ContainSameElements(expectedKeys));
}
public void EnumerateSeqBoolTest()
{
var t = EnumTable.Create <ESeq, bool>();
t[ESeq.c] = true;
foreach (var v in t)
{
if (v.Key == ESeq.c)
{
Assert.AreEqual(true, v.Value);
}
else
{
Assert.AreEqual(false, v.Value);
}
}
var keys = t.Select(x => x.Key).ToArray();
var expectedKeys = EnumHelper <ESeq> .Values.ToArray();
Assert.AreEqual(keys.Length, expectedKeys.Length);
Assert.IsTrue(keys.ContainSameElements(expectedKeys));
}
/// <summary>
/// Initializes a new instance of the <see cref="StatCollection{TStatType}"/> class.
/// </summary>
/// <param name="collectionType">The type of stat collection.</param>
public StatCollection(StatCollectionType collectionType)
{
_collectionType = collectionType;
_stats = EnumTable.Create <TStatType, StatValueType>();
}
