public void CreateUser(RegisterViewModel user)
{
OperationGroup group = db.OperationGroup.Where(m => m.Name == "Users").FirstOrDefault();
if (user != null)
{
User newUser = new User();
newUser.Id = user.Id;
newUser.Username = user.Username;
newUser.Salt = CreateSalt();
newUser.Password = user.Password;
newUser.IsActive = true;
newUser.data = DateTime.UtcNow.AddYears(1);
newUser.Operations = new List <Operation>();
newUser.OperationGroups = new List <OperationGroup>();
newUser.OperationGroups.Add(group);
foreach (Operation oper in group.Operations)
{
if (!newUser.Operations.Contains(oper))
{
newUser.Operations.Add(oper);
}
}
db.User.Add(newUser);
db.SaveChanges();
}
}
public void GroupCredentials2CheckErrorTest()
{
var op = OperationProcessor.Instance;
var groupExpectation = new AutoResetEvent(false);
var userOperationExpectation = new AutoResetEvent(false);
op.PerformOperation(typeof(LoadUserOperation), null, (Parameters result) => {
userOperationExpectation.Set();
});
OperationGroup group = new OperationGroup();
group.Credentials.Add("EXCLUSIVE_RIGHTS");
group.AddOperation(typeof(FirstOperation));
op.PerformGroup(group, null, null, (Exception e) => {
if (e.GetType().Equals(typeof(UnauthorizedAccessException)))
{
groupExpectation.Set();
}
});
Assert.True(userOperationExpectation.WaitOne(TimeSpan.FromSeconds(10)));
Assert.True(groupExpectation.WaitOne(TimeSpan.FromSeconds(10)));
}
public LongRunningOperation(OperationGroup operationGroup, Operation operation, BuildContext context) : base(context)
{
Debug.Assert(operation.IsLongRunning);
var clientClass = context.Library.FindClient(operationGroup);
Debug.Assert(clientClass != null, "clientClass != null, LROs should be disabled when public clients are disables");
DefaultName = clientClass.RestClient.ClientPrefix + operation.CSharpName() + "Operation";
FinalStateVia = operation.LongRunningFinalStateVia switch
{
"azure-async-operation" => OperationFinalStateVia.AzureAsyncOperation,
"location" => OperationFinalStateVia.Location,
"original-uri" => OperationFinalStateVia.OriginalUri,
null => OperationFinalStateVia.Location,
_ => throw new ArgumentException($"Unknown final-state-via value: {operation.LongRunningFinalStateVia}")
};
var finalResponse = operation.LongRunningFinalResponse;
Schema?finalResponseSchema = finalResponse.ResponseSchema;
if (finalResponseSchema != null)
{
ResultType = TypeFactory.GetOutputType(context.TypeFactory.CreateType(finalResponseSchema, false));
ResultSerialization = new SerializationBuilder().Build(finalResponse.HttpResponse.KnownMediaType, finalResponseSchema, ResultType);
}
else
{
ResultType = typeof(Response);
}
Description = BuilderHelpers.EscapeXmlDescription(operation.Language.Default.Description);
DefaultAccessibility = clientClass.Declaration.Accessibility;
}
public void GroupCredentials3CheckTest()
{
var op = OperationProcessor.Instance;
var groupExpectation = new AutoResetEvent(false);
var firstOperationExpectation = new AutoResetEvent(false);
var userOperationExpectation = new AutoResetEvent(false);
op.PerformOperation(typeof(LoadUserOperation), null, (Parameters result) => {
userOperationExpectation.Set();
});
OperationGroup group = new OperationGroup();
group.Credentials.Add("RUN_OPERATION");
group.AddOperation(typeof(FirstOperation), null, (Parameters result) => {
if (result.ContainsKey("1"))
{
firstOperationExpectation.Set();
}
}, null);
op.PerformGroup(group, null, (Parameters results) => {
if (results.ContainsKey("1"))
{
groupExpectation.Set();
}
});
Assert.True(userOperationExpectation.WaitOne(TimeSpan.FromSeconds(10)));
Assert.True(firstOperationExpectation.WaitOne(TimeSpan.FromSeconds(10)));
Assert.True(groupExpectation.WaitOne(TimeSpan.FromSeconds(10)));
}
public void DeleteGroup(int id)
{
OperationGroup group = FindGroup(id);
db.OperationGroup.Remove(group);
db.SaveChanges();
}
/// <inheritdoc/>
internal override bool GetNextOperation(IEnumerable <ControlledOperation> ops, ControlledOperation current,
bool isYielding, out ControlledOperation next)
{
// Set the priority of any new operation groups.
this.SetNewOperationGroupPriorities(ops, current);
// Check if there are at least two operation groups that can be scheduled,
// otherwise skip the priority checking and changing logic.
if (ops.Select(op => op.Group).Skip(1).Any())
{
// Try to change the priority of the highest priority operation group.
// If the shared-state reduction is enabled, check if there is at least
// one 'WRITE' operation, before trying to change the priority.
if (!this.Configuration.IsSharedStateReductionEnabled ||
ops.Any(op => op.LastSchedulingPoint is SchedulingPointType.Write))
{
this.TryPrioritizeNextOperationGroup(ops);
}
// Get the operations that belong to the highest priority group.
OperationGroup nextGroup = this.GetOperationGroupWithHighestPriority(ops);
ops = ops.Where(op => nextGroup.IsMember(op));
}
int idx = this.RandomValueGenerator.Next(ops.Count());
next = ops.ElementAt(idx);
this.StepCount++;
return(true);
}
public void AddGroupTest()
{
var op = OperationProcessor.Instance;
var groupExpectation = new AutoResetEvent(false);
var firstOperationExpectation = new AutoResetEvent(false);
var secondOperationExpectation = new AutoResetEvent(false);
OperationGroup group = new OperationGroup();
group.AddOperation(typeof(FirstOperation), null, (Parameters result) => {
if (result.ContainsKey("1"))
{
firstOperationExpectation.Set();
}
}, null);
group.AddOperation(typeof(SecondOperation), null, (Parameters result) => {
if (result.ContainsKey("2"))
{
secondOperationExpectation.Set();
}
}, null);
op.PerformGroup(group, null, (Parameters results) => {
if (results.ContainsKey("1") && results.ContainsKey("2"))
{
groupExpectation.Set();
}
});
Assert.True(firstOperationExpectation.WaitOne(TimeSpan.FromSeconds(10)));
Assert.True(secondOperationExpectation.WaitOne(TimeSpan.FromSeconds(10)));
Assert.True(groupExpectation.WaitOne(TimeSpan.FromSeconds(10)));
}
public OperationDefinition(OperationGroup group, HttpMethod method1, HttpMethod method2, string comp, Func<RequestAttributes, StorageOperationTypes> operation)
{
this.Group = group;
this.Method1 = method1;
this.Method2 = method2;
this.Comp = comp;
this.Operation = operation;
}
public void CreateGroup(OperationGroup group)
{
if (group != null)
{
db.OperationGroup.Add(group);
db.SaveChanges();
}
}
public OperationDefinition(OperationGroup group, HttpMethod method1, HttpMethod method2, string comp, Func <RequestAttributes, StorageOperationTypes> operation)
{
this.Group = group;
this.Method1 = method1;
this.Method2 = method2;
this.Comp = comp;
this.Operation = operation;
}
public static OperationGroupModel ToModel(this OperationGroup anOperationGroupEntity)
{
return(new OperationGroupModel()
{
Id = anOperationGroupEntity.OperGroupId,
Name = anOperationGroupEntity.Name
});
}
public Client(OperationGroup operationGroup, BuildContext context) : base(context)
{
_operationGroup = operationGroup;
_context = context;
var clientPrefix = GetClientPrefix(operationGroup.Language.Default.Name);
var clientName = clientPrefix + ClientSuffix;
DefaultName = clientName;
}
public ActionResult Edit([Bind(Include = "Id,Name")] OperationGroup operationGroup)
{
if (ModelState.IsValid)
{
gm.EditGroup(operationGroup);
return(RedirectToAction("Index"));
}
return(View(operationGroup));
}
public Operation DeleteOperation(int idGroup, int idOperation)
{
OperationGroup group = FindGroup(idGroup);
Operation oper = db.Operation.Where(m => m.Id == idOperation).FirstOrDefault();
if (group != null)
{
group.Operations.Remove(oper);
db.SaveChanges();
}
return(oper);
}
public ResponseHeaderGroupType(OperationGroup operationGroup, Operation operation, HttpResponseHeader[] httpResponseHeaders, BuildContext context) : base(context)
{
ResponseHeader CreateResponseHeader(HttpResponseHeader header) =>
new ResponseHeader(header.Header.ToCleanName(), header.Header, context.TypeFactory.CreateType(header.Schema, true));
string operationName = operation.CSharpName();
var clientName = context.Library.FindRestClient(operationGroup).ClientPrefix;
DefaultName = clientName + operationName + "Headers";
Description = $"Header model for {operationName}";
Headers = httpResponseHeaders.Select(CreateResponseHeader).ToArray();
}
// GET: OperationGroups/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
OperationGroup operationGroup = gm.FindGroup(id);
if (operationGroup == null)
{
return(HttpNotFound());
}
return(View(operationGroup));
}
public void beginGroup(string name)
{
OperationGroup opGroup = new OperationGroup();
opGroup.name = name;
if (groups.Count == 0)
{
operations.Push(opGroup);
groups.Push(opGroup);
}
else
{
currGroup.add(opGroup);
}
}
public static ResponseHeaderGroupType?TryCreate(OperationGroup operationGroup, Operation operation, BuildContext context)
{
var httpResponseHeaders = operation.Responses.SelectMany(r => r.HttpResponse.Headers)
.Where(h => !_knownResponseHeaders.Contains(h.Header, StringComparer.InvariantCultureIgnoreCase))
.GroupBy(h => h.Header)
// Take first header definition with any particular name
.Select(h => h.First())
.ToArray();
if (!httpResponseHeaders.Any() || operation.IsLongRunning)
{
return(null);
}
return(new ResponseHeaderGroupType(operationGroup, operation, httpResponseHeaders, context));
}
/// <summary>
/// Invokes the middleware to controls the specified request.
/// </summary>
#pragma warning disable CA1822
public async SystemTask InvokeAsync(WebFramework.HttpContext context)
{
WebFramework.HttpRequest request = context.Request;
if (request != null && TryExtractRuntime(request, out CoyoteRuntime runtime))
{
IO.Debug.WriteLine("<Coyote> Runtime '{0}' takes control of the '{1} {2}' handler on thread '{3}'.",
runtime.Id, request.Method, request.Path, SystemThread.CurrentThread.ManagedThreadId);
TryExtractSourceOperation(request, runtime, out ControlledOperation source);
var op = HttpOperation.Create(ToHttpMethod(request.Method), request.Path, runtime, source);
OperationGroup.SetCurrent(op.Group);
await runtime.TaskFactory.StartNew(state =>
{
SystemTask task = this.Next(context);
runtime.WaitUntilTaskCompletes(task);
task.GetAwaiter().GetResult();
},
op,
public static OperationGroup FromBaseObject(BaseObject baseObj)
{
if (baseObj == null || baseObj.NativeObject == IntPtr.Zero)
{
return(null);
}
OperationGroup obj = baseObj as OperationGroup;
if (object.Equals(obj, null))
{
obj = new OperationGroup(CreatedWhenConstruct.CWC_NotToCreate);
obj.BindNativeObject(baseObj.NativeObject, "COperationGroup");
obj.IncreaseCast();
}
return(obj);
}
public PopupMenuButton CreateSplitButton(SplitButtonParams buttonParams, OperationGroup operationGroup = null)
{
PopupMenuButton menuButton = null;
var innerButton = new IconButton(buttonParams.Icon, this)
{
Name = buttonParams.ButtonName + " Inner SplitButton",
ToolTipText = buttonParams.DefaultActionTooltip,
};
innerButton.Click += (s, e) =>
{
buttonParams.DefaultAction.Invoke(menuButton);
};
// Remove right Padding for drop style
innerButton.Padding = innerButton.Padding.Clone(right: 0);
if (operationGroup == null)
{
menuButton = new PopupMenuButton(innerButton, this);
}
else
{
menuButton = new OperationGroupButton(operationGroup, innerButton, this);
}
menuButton.DynamicPopupContent = () =>
{
var popupMenu = new PopupMenu(ApplicationController.Instance.MenuTheme);
buttonParams.ExtendPopupMenu?.Invoke(popupMenu);
return(popupMenu);
};
menuButton.Name = buttonParams.ButtonName + " Menu SplitButton";
menuButton.BackgroundColor = this.ToolbarButtonBackground;
menuButton.HoverColor = this.ToolbarButtonHover;
menuButton.MouseDownColor = this.ToolbarButtonDown;
menuButton.DrawArrow = true;
menuButton.Margin = this.ButtonSpacing;
menuButton.DistinctPopupButton = true;
innerButton.Selectable = true;
return(menuButton);
}
public void DeleteGroup(int idUser, int idGroup)
{
User user = Find(idUser);
OperationGroup group = db.OperationGroup.Where(m => m.Id == idGroup).FirstOrDefault();
if (user != null)
{
user.OperationGroups.Remove(group);
foreach (Operation oper in group.Operations)
{
if (user.Operations.Contains(oper))
{
user.Operations.Remove(oper);
}
}
db.SaveChanges();
}
}
public RestClient(OperationGroup operationGroup, BuildContext context) : base(context)
{
_operationGroup = operationGroup;
_context = context;
_parameters = operationGroup.Operations
.SelectMany(op => op.Parameters.Concat(op.Requests.SelectMany(r => r.Parameters)))
.Where(p => p.Implementation == ImplementationLocation.Client)
.Distinct()
.ToDictionary(p => p.Language.Default.Name, BuildClientParameter);
_serializationBuilder = new SerializationBuilder();
Parameters = OrderParameters(_parameters.Values);
var mainClient = context.Library.FindClient(operationGroup);
ClientPrefix = GetClientPrefix(mainClient?.Declaration.Name ?? operationGroup.Language.Default.Name);
DefaultName = ClientPrefix + RestClientSuffix;
Description = "";
}
/// <summary>
/// 初始化单个操作分组
/// </summary>
/// <param name="group">操作分组</param>
/// <param name="allGroups">所有操作分组数据</param>
/// <returns>返回执行结果</returns>
Result InitializeSingleGroup(OperationGroup group, IEnumerable <OperationGroup> allGroups)
{
if (group == null)
{
return(Result.FailedResult("分组信息为空"));
}
var saveResult = Save(group);
if (saveResult?.Success ?? false)
{
group = saveResult.Object;
var childGroups = allGroups?.Where(c => c.Parent?.Name == group.Name);
foreach (var childGroup in childGroups)
{
childGroup.SetParent(group);
InitializeSingleGroup(childGroup, childGroups);
}
}
return(saveResult);
}
public void ResolveDependenciesInOperationsErrorTest()
{
var op = OperationProcessor.Instance;
op.Initialize();
var groupExpectation = new AutoResetEvent(false);
OperationGroup group = new OperationGroup();
group.AddOperation(typeof(DependenciesRequiredOperation));
op.PerformGroup(group, null, null, (Exception e) => {
if (e != null)
{
groupExpectation.Set();
}
});
Assert.True(groupExpectation.WaitOne(TimeSpan.FromSeconds(10)));
}
/// <summary>
/// Reduces the priority of highest priority operation group, if there is a priority
/// change point installed on the current execution step.
/// </summary>
private bool TryPrioritizeNextOperationGroup(IEnumerable <ControlledOperation> ops)
{
OperationGroup group = null;
if (this.PriorityChangePoints.Contains(this.NumPriorityChangePoints))
{
// This scheduling step was chosen as a priority change point.
group = this.GetOperationGroupWithHighestPriority(ops);
Debug.WriteLine("<ScheduleLog> Reduced the priority of operation group '{0}'.", group);
}
this.NumPriorityChangePoints++;
if (group != null)
{
// Reduce the priority of the group by putting it in the end of the list.
this.PrioritizedOperationGroups.Remove(group);
this.PrioritizedOperationGroups.Add(group);
return(true);
}
return(false);
}
public void ResolveDependenciesInOperationsTest()
{
var op = OperationProcessor.Instance;
var groupExpectation = new AutoResetEvent(false);
OperationGroup group = new OperationGroup();
group.AddOperation(typeof(DependenciesOptionalOperation));
group.AddOperation(typeof(DependenciesRequiredOperation));
op.PerformGroup(group, null, (Parameters results) => {
if (results.ContainsKey("Count"))
{
var value = results ["Count"];
if (value.Equals("2"))
{
groupExpectation.Set();
}
}
});
Assert.True(groupExpectation.WaitOne(TimeSpan.FromSeconds(10)));
}
public void beginGroup(string name)
{
OperationGroup opGroup = new OperationGroup();
opGroup.name = name;
if(groups.Count == 0)
{
operations.Push(opGroup);
groups.Push(opGroup);
}
else
currGroup.add(opGroup);
}
/// <summary>
/// 保存操作分组
/// </summary>
/// <param name="newOperationGroup">操作分组对象</param>
/// <returns>执行结果</returns>
public Result <OperationGroup> Save(OperationGroup newOperationGroup)
{
return(newOperationGroup?.Save() ?? Result <OperationGroup> .FailedResult("操作分组保存失败"));
}
protected static string CreateDescription(OperationGroup operationGroup, string clientPrefix)
{
return(string.IsNullOrWhiteSpace(operationGroup.Language.Default.Description) ?
$"The {clientPrefix} service client." :
BuilderHelpers.EscapeXmlDescription(operationGroup.Language.Default.Description));
}
private OperationGroup BuildOperationGroups(String filter, OperationGroup startGroup = null)
{
startGroup = startGroup ?? new OperationGroup();
var regEx = new Regex(@":(and|or):\(([^\)]+)\)*");
var matches = regEx.Matches(filter);
filter = regEx.Replace(filter, String.Empty);
if (filter.StartsWith("("))
{
var startGroupRegEx = new Regex(@"\(([^\)]+)\)*");
var matchString = startGroupRegEx.Match(filter).Value;
var ungroupedFilter = startGroupRegEx.Replace(filter, String.Empty);
if (String.IsNullOrEmpty(ungroupedFilter))
{
filter = filter.Remove(0, 1);
filter = filter.Remove(filter.Length - 1);
startGroup.Operations.AddRange(this.BuildOperations(filter));
}
else
{
var subGroup = new OperationSubGroup();
if (ungroupedFilter.StartsWith(":and:"))
{
subGroup.JoinOperator = OperationsOperators.And;
matchString = matchString.Remove(0, 1);
matchString = matchString.Remove(matchString.Length - 1);
ungroupedFilter = ungroupedFilter.Remove(0, 5);
}
else
{
subGroup.JoinOperator = OperationsOperators.Or;
matchString = matchString.Remove(0, 1);
matchString = matchString.Remove(matchString.Length - 1);
ungroupedFilter = ungroupedFilter.Remove(0, 4);
}
startGroup.SubGroups.Add((OperationSubGroup)this.BuildOperationGroups(matchString, subGroup));
startGroup.Operations.AddRange(this.BuildOperations(ungroupedFilter));
}
}
else
startGroup.Operations.AddRange(this.BuildOperations(filter));
foreach (Match group in matches)
{
var subGroup = new OperationSubGroup();
var matchString = group.ToString();
if (matchString.StartsWith(":and:"))
{
subGroup.JoinOperator = OperationsOperators.And;
matchString = matchString.Remove(0, 6);
matchString = matchString.Remove(matchString.Length - 1);
}
else
{
subGroup.JoinOperator = OperationsOperators.Or;
matchString = matchString.Remove(0, 5);
matchString = matchString.Remove(matchString.Length - 1);
}
startGroup.SubGroups.Add((OperationSubGroup)this.BuildOperationGroups(matchString, subGroup));
}
return startGroup;
}
protected Expression BuildWhereClause(OperationGroup operationGroup)
{
Expression previousExpression = null;
Expression topExpression = null;
var validFilters = operationGroup.Operations.Where(opp => !IgnoreFilter(opp.Filter));
if (validFilters.Count() == 0)
return null;
foreach (Operation opp in validFilters)
{
Expression ex = BuildFilterExpression(opp.Filter, ParameterExpression);
if (opp.Operator != null)
{
switch (opp.Operator.ToLower())
{
case OperationsOperators.And:
ex = Expression.And(topExpression, ex);
break;
case OperationsOperators.Or:
ex = Expression.Or(topExpression, ex);
break;
}
}
topExpression = ex;
}
if (operationGroup.SubGroups.Count() > 0)
{
foreach (OperationSubGroup subGroup in operationGroup.SubGroups)
{
var subGroupExpression = this.BuildWhereClause(subGroup);
if (previousExpression != null)
switch (subGroup.JoinOperator)
{
case OperationsOperators.And:
previousExpression = Expression.And(previousExpression, subGroupExpression);
break;
case OperationsOperators.Or:
previousExpression = Expression.Or(previousExpression, subGroupExpression);
break;
}
else
previousExpression = subGroupExpression;
}
//If no filters were applied then we might have a null expression
if (previousExpression != null)
{
var topJoin = operationGroup.SubGroups.First().JoinOperator;
switch (topJoin)
{
case OperationsOperators.And:
topExpression = Expression.And(topExpression, previousExpression);
break;
case OperationsOperators.Or:
topExpression = Expression.Or(topExpression, previousExpression);
break;
}
}
}
return topExpression;
}
public PopupMenuButton CreateSplitButton(SplitButtonParams buttonParams, OperationGroup operationGroup = null)
{
PopupMenuButton menuButton = null;
GuiWidget innerButton;
if (buttonParams.ButtonText == null)
{
innerButton = new IconButton(buttonParams.Icon, this)
{
Name = buttonParams.ButtonName + " Inner SplitButton",
Enabled = buttonParams.ButtonEnabled,
ToolTipText = buttonParams.ButtonTooltip,
};
// Remove right Padding for drop style
innerButton.Padding = innerButton.Padding.Clone(right: 0);
}
else
{
if (buttonParams.Icon == null)
{
innerButton = new TextButton(buttonParams.ButtonText, this)
{
Name = buttonParams.ButtonName,
Enabled = buttonParams.ButtonEnabled,
ToolTipText = buttonParams.ButtonTooltip,
};
}
else
{
innerButton = new TextIconButton(buttonParams.ButtonText, buttonParams.Icon, this)
{
Name = buttonParams.ButtonName,
Enabled = buttonParams.ButtonEnabled,
ToolTipText = buttonParams.ButtonTooltip,
};
}
}
innerButton.Click += (s, e) =>
{
buttonParams.ButtonAction.Invoke(menuButton);
};
if (operationGroup == null)
{
menuButton = new PopupMenuButton(innerButton, this);
}
else
{
menuButton = new OperationGroupButton(operationGroup, innerButton, this);
}
var theme = ApplicationController.Instance.MenuTheme;
menuButton.DynamicPopupContent = () =>
{
var popupMenu = new PopupMenu(theme);
buttonParams.ExtendPopupMenu?.Invoke(popupMenu);
return(popupMenu);
};
menuButton.Name = buttonParams.ButtonName + " Menu SplitButton";
if (buttonParams.ButtonText == null)
{
menuButton.BackgroundColor = this.ToolbarButtonBackground;
}
else
{
menuButton.BackgroundColor = this.MinimalShade;
}
menuButton.HoverColor = this.ToolbarButtonHover;
menuButton.MouseDownColor = this.ToolbarButtonDown;
menuButton.DrawArrow = true;
menuButton.Margin = this.ButtonSpacing;
menuButton.DistinctPopupButton = true;
menuButton.BackgroundRadius = new RadiusCorners(theme.ButtonRadius, theme.ButtonRadius, 0, 0);
innerButton.Selectable = true;
return(menuButton);
}
public OperationDefinition(OperationGroup group, HttpMethod method1, HttpMethod method2, string comp, StorageOperationTypes operation)
: this(group, method1, method2, comp, (attribs) => operation)
{
}
public void EditGroup(OperationGroup group)
{
db.Entry(group).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
static IDictionary<HttpMethod, Dictionary<string, Func<RequestAttributes, StorageOperationTypes>>> CreateGroupDefinitions(OperationGroup group)
{
return _operations
.Where(op => op.Group == group)
.SelectMany(op => new[] { Tuple.Create(op.Method1, op) }.Concat( op.Method2 != null ? new[] { Tuple.Create(op.Method2, op)} : Enumerable.Empty<Tuple<HttpMethod, OperationDefinition>>()))
.GroupBy(op => op.Item1, op => op.Item2)
.ToDictionary(methodOps => methodOps.Key, methodOps => methodOps
.ToDictionary(op => op.Comp, op => op.Operation, StringComparer.OrdinalIgnoreCase));
}
