public object AddGroupInfo(string name, string description)
{
try
{
GroupInfo info = GroupOperation.GetGroupInfoByName(name);
if (null == info)
{
GroupInfo obj = new GroupInfo()
{
id = Guid.NewGuid(),
name = name,
description = description,
status = 1,
updatetime = DateTime.Now
};
GroupOperation.AddOrUpdateGroupInfo(obj, EnumAddOrUpdate.Add);
return(string.Format("添加组【{0}】信息成功！", name));
}
else
{
return(string.Format("系统已存在组【{0}】信息!", name));
}
}
catch (Exception ex)
{
return(ex.Message);
}
}
public LoginForm()
{
InitializeComponent();
userOperation = new UserOperation(new UserRepository());
algorithmOperation = new AlgorithmOperation(new AlgorithmRepository());
groupOperation = new GroupOperation(new AccessGroupRepository());
}
public object GetGroupInfoList(string fields, string key, string order, string ascOrdesc, int page, int rows)
{
try
{
if (string.IsNullOrEmpty(fields))
{
fields = "*";
}
PageInfo pageInfo = new PageInfo()
{
PageIndex = (page - 1) * rows,
PageSize = rows,
RecCount = 0
};
string where = string.Empty;
if (!string.IsNullOrEmpty(key))
{
where = string.Format("where name like '%{0}%' or description like '%{0}%' ", key);
}
string orderby = string.Format("order by {0} {1}", order, ascOrdesc);
string limit = string.Format("limit {0},{1}", pageInfo.PageIndex, pageInfo.PageSize);
List <GroupInfo> list = GroupOperation.GetGroupInfoListAll(fields, where);
pageInfo.RecCount = list.Count;
List <GroupInfo> target = GroupOperation.GetGroupInfoPageList(fields, where, orderby, limit);
GridResult <GroupInfo> result = new GridResult <GroupInfo>(target, pageInfo.RecCount);
return(new JsonResult(result));
}
catch (Exception ex)
{
return(ex.Message);
}
}
public ChooseFileForm(int _userId, AlgorithmOperation _ao, GroupOperation _go)
{
InitializeComponent();
algorithmOperation = _ao;
groupOperation = _go;
USERID = _userId;
algList_listbox.DataSource = algorithmOperation.GetTitles(USERID);
}
public AllUsersForm(UserOperation _uo, AlgorithmOperation _ao, GroupOperation _go)
{
InitializeComponent();
userOperation = _uo;
algorithmOperation = _ao;
groupOperation = _go;
usersList_listbox.DataSource = userOperation.GetUsernames();
}
private void ef_rb_CheckedChanged(object sender, EventArgs e)
{
if (ef_rb.Checked)
{
userOperation = new UserOperation(new UserRepositoryEF());
algorithmOperation = new AlgorithmOperation(new AlgorithmRepositoryEF());
groupOperation = new GroupOperation(new AccessGroupRepositoryEF());
}
}
private string ExportItemCSV(GroupOperation item)
{
const string DELIMITER = ";";
var csv = new StringBuilder();
csv.AppendFormat("\"{0}\"", item.AccountNumber ?? item.Active ?? item.OperationType); csv.Append(DELIMITER);
csv.AppendFormat("\"{0}\"", item.Quantity); csv.Append(DELIMITER);
csv.AppendFormat("{0}", item.AveragePrice.ToString("0.00", System.Globalization.CultureInfo.InvariantCulture)); csv.Append(DELIMITER);
return(csv.ToString());
}
public AddUserAccessForm(int _userId, UserOperation _uo, AlgorithmOperation _ao, GroupOperation _go)
{
InitializeComponent();
userId = _userId;
userOperation = _uo;
algorithmOperation = _ao;
groupOperation = _go;
algorithm_cb.DataSource = algorithmOperation.GetUserAlgorithmTitles(userId);
}
public OtherUsersAlgorithmsForm(int _userId, UserOperation _uo, AlgorithmOperation _ao, GroupOperation _go)
{
InitializeComponent();
userId = _userId;
userOperation = _uo;
algorithmOperation = _ao;
groupOperation = _go;
userList_cb.DataSource = userOperation.GetUsernames();
}
private void button11_Click(object sender, EventArgs e)
{
GroupInfo info = new GroupInfo()
{
id = new Guid("4ae75530-a9a4-4f0a-ae4c-5f35d009b611"),
name = "默认组",
description = "所有用户若未被分配组均属于默认组",
updatetime = DateTime.Now,
status = 1
};
bool ret = GroupOperation.AddOrUpdateGroupInfo(info, EnumAddOrUpdate.Update);
}
public void NeedUserAcknowledgement_changed_should_change_etag()
{
var group = new GroupOperation();
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.NeedUserAcknowledgement = true;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void RetryProgress_changed_should_change_etag()
{
var group = new GroupOperation();
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.OperationProgress = 0.01;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void RetryCompletionTime_changed_should_change_etag()
{
var group = new GroupOperation();
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.OperationCompletionTime = DateTime.UtcNow;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public string SaveSecurityGroup(string operation, GroupOperation parameter)
{
try
{
string result = ValueData.GeneralValue <string>("SecurityManage", "ManageGroupMember", parameter);
return(result);
}
catch (Exception ex)
{
var em = ex.Message;
return("Failed");
}
}
public void Changing_item_count_should_change_etag()
{
var data = new GroupOperation[0];
var knownEtag = EtagHelper.CalculateEtag(data);
var group = new GroupOperation();
data = new[] { group };
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void RetryStatus_changed_should_change_etag()
{
var group = new GroupOperation {
OperationStatus = RetryState.Waiting.ToString()
};
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.OperationStatus = RetryState.Preparing.ToString();
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void Count_changed_should_change_etag()
{
var group = new GroupOperation {
Count = 1
};
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.Count = 2;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void Id_changed_should_change_etag()
{
var group = new GroupOperation {
Id = "old"
};
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.Id = "new";
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public string SaveGroupTeacher(string operation, GroupOperation parameter)
{
try
{
parameter.Operate = operation;
string sp = "dbo.SIC_sys_UserGroupMember_Teachers @Operate,@UserID,@UserRole,@SchoolYear,@SchooCode,@CPNum,@AppID,@GroupID,@Permission,@StartDate,@EndDate,@Comments";
string result = AppsBase.GeneralValue <string>(sp, parameter);
return(result);
}
catch (Exception ex)
{
var em = ex.Message;
return("Failed");
}
}
public UserForm(int _userId, bool _admin, UserOperation _uo, AlgorithmOperation _ao, GroupOperation _go)
{
InitializeComponent();
USERID = _userId;
admin = _admin;
списокКористувачівToolStripMenuItem.Visible = всіАлгоритмиToolStripMenuItem.Visible = admin;
списокКористувачівToolStripMenuItem.Enabled = всіАлгоритмиToolStripMenuItem.Enabled = admin;
userOperation = _uo;
algoritmOperation = _ao;
groupOperation = _go;
}
public object DeleteGroupInfoById(string id)
{
try
{
GroupInfo info = GroupOperation.GetGroupInfoById(new Guid(id));
if (null != info)
{
GroupOperation.DeleteGroupInfo(new Guid(id));
return(string.Format("删除组【{0}】信息成功！", info.name));
}
else
{
return(string.Format("删除失败，系统不存在编号【{0}】组信息！", id));
}
}
catch (Exception ex)
{
return(ex.Message);
}
}
public void constructor_with_key_should_initialize_subject()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var filter = new BsonDocument("y", 1);
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation<BsonDocument>(collectionNamespace, key, initial, reduceFunction, filter, messageEncoderSettings);
subject.CollectionNamespace.Should().Be(collectionNamespace);
subject.Filter.Should().Be(filter);
subject.FinalizeFunction.Should().BeNull();
subject.Initial.Should().Be(initial);
subject.Key.Should().Be(key);
subject.KeyFunction.Should().BeNull();
subject.MaxTime.Should().Be(default(TimeSpan?));
Assert.Equal(messageEncoderSettings, subject.MessageEncoderSettings);
subject.ReduceFunction.Should().Be(reduceFunction);
subject.ResultSerializer.Should().BeNull();
}
public IEnumerator PercentComplete_CalculationIsCorrect_WhenInAGroupOperation()
{
yield return(Init());
GroupOperation groupOp = new GroupOperation();
float handle1PercentComplete = 0.22f;
float handle2PercentComplete = 0.78f;
float handle3PercentComplete = 1.0f;
float handle4PercentComplete = 0.35f;
List <AsyncOperationHandle> handles = new List <AsyncOperationHandle>()
{
new ManualPercentCompleteOperation(handle1PercentComplete).Handle,
new ManualPercentCompleteOperation(handle2PercentComplete).Handle,
new ManualPercentCompleteOperation(handle3PercentComplete).Handle,
new ManualPercentCompleteOperation(handle4PercentComplete).Handle
};
groupOp.Init(handles);
Assert.AreEqual((handle1PercentComplete + handle2PercentComplete + handle3PercentComplete + handle4PercentComplete) / 4, groupOp.PercentComplete);
}
private void button10_Click(object sender, EventArgs e)
{
string name = "内部人员";
GroupInfo info = new GroupInfo()
{
id = Guid.NewGuid(),
name = name,
description = name,
updatetime = DateTime.Now,
status = 1
};
GroupInfo info2 = GroupOperation.GetGroupInfoByName(name);
bool ret = false;
if (null == info2)
{
ret = GroupOperation.AddOrUpdateGroupInfo(info, EnumAddOrUpdate.Add);
}
else
{
MessageBox.Show(string.Format("{0}已存在！", "默认组"));
}
}
public object UpdateGroupInfo(string id, string description, int status)
{
try
{
GroupInfo info = GroupOperation.GetGroupInfoById(new Guid(id));
if (null != info)
{
info.description = description;
info.status = status;
info.updatetime = DateTime.Now;
GroupOperation.AddOrUpdateGroupInfo(info, EnumAddOrUpdate.Update);
return(string.Format("更新组【{0}】信息成功！", info.name));
}
else
{
return(string.Format("修改失败，系统不存在编号【{0}】组信息！", id));
}
}
catch (Exception ex)
{
return(ex.Message);
}
}
public void ResultSerializer_should_work()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var filter = new BsonDocument("y", 1);
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation<BsonDocument>(collectionNamespace, key, initial, reduceFunction, filter, messageEncoderSettings);
var resultSerializer = new Mock<IBsonSerializer<BsonDocument>>().Object;
subject.ResultSerializer = resultSerializer;
subject.ResultSerializer.Should().BeSameAs(resultSerializer);
}
public void FinalizeFunction_should_work()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var filter = new BsonDocument("y", 1);
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation<BsonDocument>(collectionNamespace, key, initial, reduceFunction, filter, messageEncoderSettings);
var finalizeFunction = new BsonJavaScript("finalizeFunction");
subject.FinalizeFunction = finalizeFunction;
subject.FinalizeFunction.Should().Be(finalizeFunction);
}
public void MaxTime_should_work()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var filter = new BsonDocument("y", 1);
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation<BsonDocument>(collectionNamespace, key, initial, reduceFunction, filter, messageEncoderSettings);
var maxTime = TimeSpan.FromSeconds(1);
subject.MaxTime = maxTime;
subject.MaxTime.Should().Be(maxTime);
}
public void CreateCommand_should_return_expected_result_when_maxTime_was_provided()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation<BsonDocument>(collectionNamespace, key, initial, reduceFunction, null, messageEncoderSettings);
subject.MaxTime = TimeSpan.FromSeconds(1);
var expectedResult = new BsonDocument
{
{ "group", new BsonDocument
{
{ "ns", collectionNamespace.CollectionName },
{ "key", key },
{ "$reduce", reduceFunction },
{ "initial", initial }
}
},
{ "maxTimeMS", 1000 }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
public void AddFieldIndex(int fieldIndex, GroupOperation operation)
{
_operations.AddFieldIndex(fieldIndex, (tkFieldStatOperation)operation);
}
public void AddFieldName(string fieldName, GroupOperation operation)
{
_operations.AddFieldName(fieldName, (tkFieldStatOperation)operation);
}
private IEnumerable <DataSourceValueGroup> ExecuteSeriesFunction(Target sourceTarget, Tuple <SeriesFunction, string, GroupOperation> parsedFunction, DateTime startTime, DateTime stopTime, string interval, bool decimate, bool dropEmptySeries, CancellationToken cancellationToken)
{
SeriesFunction seriesFunction = parsedFunction.Item1;
string expression = parsedFunction.Item2;
GroupOperation groupOperation = parsedFunction.Item3;
// Parse out function parameters and target expression
Tuple <string[], string> expressionParameters = TargetCache <Tuple <string[], string> > .GetOrAdd(expression, () =>
{
List <string> parsedParameters = new List <string>();
// Extract any required function parameters
int requiredParameters = s_requiredParameters[seriesFunction]; // Safe: no lock needed since content doesn't change
// Any slice operation adds one required parameter for time tolerance
if (groupOperation == GroupOperation.Slice)
{
requiredParameters++;
}
if (requiredParameters > 0)
{
int index = 0;
for (int i = 0; i < requiredParameters && index > -1; i++)
{
index = expression.IndexOf(',', index + 1);
}
if (index > -1)
{
parsedParameters.AddRange(expression.Substring(0, index).Split(','));
}
if (parsedParameters.Count == requiredParameters)
{
expression = expression.Substring(index + 1).Trim();
}
else
{
throw new FormatException($"Expected {requiredParameters + 1} parameters, received {parsedParameters.Count + 1} in: {(groupOperation == GroupOperation.None ? "" : groupOperation.ToString())}{seriesFunction}({expression})");
}
}
// Extract any provided optional function parameters
int optionalParameters = s_optionalParameters[seriesFunction]; // Safe: no lock needed since content doesn't change
bool hasSubExpression(string target) => target.StartsWith("FILTER", StringComparison.OrdinalIgnoreCase) || target.Contains("(");
if (optionalParameters > 0)
{
int index = expression.IndexOf(',');
int lastIndex;
if (index > -1 && !hasSubExpression(expression.Substring(0, index)))
{
lastIndex = index;
for (int i = 1; i < optionalParameters && index > -1; i++)
{
index = expression.IndexOf(',', index + 1);
if (index > -1 && hasSubExpression(expression.Substring(lastIndex + 1, index - lastIndex - 1).Trim()))
{
index = lastIndex;
break;
}
lastIndex = index;
}
if (index > -1)
{
parsedParameters.AddRange(expression.Substring(0, index).Split(','));
expression = expression.Substring(index + 1).Trim();
}
}
}
return(new Tuple <string[], string>(parsedParameters.ToArray(), expression));
});
string[] parameters = expressionParameters.Item1;
string queryExpression = expressionParameters.Item2; // Final function parameter is always target expression
// When accurate calculation results are requested, query data source at full resolution
if (seriesFunction == SeriesFunction.Interval && ParseFloat(parameters[0]) == 0.0D)
{
decimate = false;
}
// Query function expression to get series data
IEnumerable <DataSourceValueGroup> dataset = QueryTarget(sourceTarget, queryExpression, startTime, stopTime, interval, decimate, dropEmptySeries, cancellationToken);
// Handle label function as a special edge case - group operations on label are ignored
if (seriesFunction == SeriesFunction.Label)
{
// Derive labels
string label = parameters[0];
if (label.StartsWith("\"") || label.StartsWith("'"))
{
label = label.Substring(1, label.Length - 2);
}
DataSourceValueGroup[] valueGroups = dataset.ToArray();
string[] seriesLabels = new string[valueGroups.Length];
for (int i = 0; i < valueGroups.Length; i++)
{
string target = valueGroups[i].RootTarget;
seriesLabels[i] = TargetCache <string> .GetOrAdd($"{label}@{target}", () =>
{
string table, derivedLabel;
string[] components = label.Split('.');
if (components.Length == 2)
{
table = components[0].Trim();
derivedLabel = components[1].Trim();
}
else
{
table = "ActiveMeasurements";
derivedLabel = label;
}
DataRow record = target.MetadataRecordFromTag(Metadata, table);
if (record != null && derivedLabel.IndexOf('{') >= 0)
{
foreach (string fieldName in record.Table.Columns.Cast <DataColumn>().Select(column => column.ColumnName))
{
derivedLabel = derivedLabel.ReplaceCaseInsensitive($"{{{fieldName}}}", record[fieldName].ToString());
}
}
// ReSharper disable once AccessToModifiedClosure
if (derivedLabel.Equals(label, StringComparison.Ordinal))
{
derivedLabel = $"{label}{(valueGroups.Length > 1 ? $" {i + 1}" : "")}";
}
return(derivedLabel);
});
}
// Verify that all series labels are unique
if (seriesLabels.Length > 1)
{
HashSet <string> uniqueLabelSet = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
for (int i = 0; i < seriesLabels.Length; i++)
{
while (uniqueLabelSet.Contains(seriesLabels[i]))
{
seriesLabels[i] = $"{seriesLabels[i]}\u00A0"; // Suffixing with non-breaking space for label uniqueness
}
uniqueLabelSet.Add(seriesLabels[i]);
}
}
for (int i = 0; i < valueGroups.Length; i++)
{
yield return(new DataSourceValueGroup
{
Target = seriesLabels[i],
RootTarget = valueGroups[i].RootTarget,
SourceTarget = sourceTarget,
Source = valueGroups[i].Source,
DropEmptySeries = dropEmptySeries
});
}
}
else
{
switch (groupOperation)
{
case GroupOperation.Set:
{
// Flatten all series into a single enumerable
DataSourceValueGroup valueGroup = new DataSourceValueGroup
{
Target = $"Set{seriesFunction}({string.Join(", ", parameters)}{(parameters.Length > 0 ? ", " : "")}{queryExpression})",
RootTarget = queryExpression,
SourceTarget = sourceTarget,
Source = ExecuteSeriesFunctionOverSource(dataset.AsParallel().WithCancellation(cancellationToken).SelectMany(source => source.Source), seriesFunction, parameters),
DropEmptySeries = dropEmptySeries
};
// Handle edge-case set operations - for these functions there is data in the target series as well
if (seriesFunction == SeriesFunction.Minimum || seriesFunction == SeriesFunction.Maximum || seriesFunction == SeriesFunction.Median)
{
DataSourceValue dataValue = valueGroup.Source.First();
valueGroup.Target = $"Set{seriesFunction} = {dataValue.Target}";
valueGroup.RootTarget = dataValue.Target;
}
yield return(valueGroup);
break;
}
case GroupOperation.Slice:
{
TimeSliceScanner scanner = new TimeSliceScanner(dataset, ParseFloat(parameters[0]) / SI.Milli);
parameters = parameters.Skip(1).ToArray();
foreach (DataSourceValueGroup valueGroup in ExecuteSeriesFunctionOverTimeSlices(scanner, seriesFunction, parameters, cancellationToken))
{
yield return(new DataSourceValueGroup
{
Target = $"Slice{seriesFunction}({string.Join(", ", parameters)}{(parameters.Length > 0 ? ", " : "")}{valueGroup.Target})",
RootTarget = valueGroup.RootTarget ?? valueGroup.Target,
SourceTarget = sourceTarget,
Source = valueGroup.Source,
DropEmptySeries = dropEmptySeries
});
}
break;
}
default:
{
foreach (DataSourceValueGroup valueGroup in dataset)
{
yield return(new DataSourceValueGroup
{
Target = $"{seriesFunction}({string.Join(", ", parameters)}{(parameters.Length > 0 ? ", " : "")}{valueGroup.Target})",
RootTarget = valueGroup.RootTarget ?? valueGroup.Target,
SourceTarget = sourceTarget,
Source = ExecuteSeriesFunctionOverSource(valueGroup.Source, seriesFunction, parameters),
DropEmptySeries = dropEmptySeries
});
}
break;
}
}
}
}
private void button12_Click(object sender, EventArgs e)
{
Guid id = new Guid("1e143ba4-7805-46ce-a123-95cb850795ac");
bool ret = GroupOperation.DeleteGroupInfo(id);
}
