public void TestResolve(TestEnum expected, string key, string value)
{
var resolver = new EnumResolver <TestEnum>();
var model = new ArgumentModel(key, value);
Assert.Equal(expected, resolver.Resolve(model));
}
public void VisitEmptyMethod(QNode node)
{
var left = this.ContextExpression.Pop();
var method = EnumResolver.ResolveNodeType(node.Type);
if (method == NodeType.ToString)
{
var toStringMethod = typeof(object).GetMethod("ToString", new Type[] { });
var exp = Expression.Call(left, toStringMethod, null);
this.ContextExpression.Push(exp);
}
else if (method == NodeType.ToLower)
{
var exp = Expression.Call(left, Methods.ToLower, null);
this.ContextExpression.Push(exp);
}
else
{
var types = new List <Type>
{
left.Type.GetTypeInfo().IsGenericType
? left.Type.GenericTypeArguments[0]
: left.Type
};
var exp = Expression.Call(typeof(Enumerable), method.ToString(), types.ToArray(), left);
this.ContextExpression.Push(exp);
}
}
public ActionResult Months()
{
var months = new EMonth().ConvertToCollection();
months.ForEach(month => month.Name = EnumResolver.Month(month.Value));
return(new JsonFactory().Success(months));
}
public void VisitBinary(QNode node)
{
var right = this.ContextExpression.Pop();
var left = this.ContextExpression.Pop();
var op = EnumResolver.ResolveNodeType(node.Type);
var exp = this.BuildBinaryExpression(op, left, right);
this.ContextExpression.Push(exp);
}
public JsonResult GetUnits()
{
var units = new UnitType().ConvertToCollection();
foreach (var unit in units)
{
unit.Name = EnumResolver.Unit(unit.Value);
}
return(new JsonFactory().Success(units, units.Count));
}
protected virtual IResolver MakeResolver()
{
var services = this.MakeServices();
var resolver = NoneResolver.Instance;
resolver = new EnumResolver(resolver);
resolver = new ArrayResolver(resolver, services);
resolver = new ActivityResolver(resolver);
resolver = new EventActivityValueResolver(resolver);
resolver = new InvokeActivityValueResolver(resolver);
return(resolver);
}
protected virtual IResolver MakeResolver()
{
var services = this.MakeServices();
var resolver = NoneResolver.Instance;
resolver = new EnumResolver(resolver);
resolver = new ArrayResolver(resolver, services);
resolver = new ActivityResolver(resolver);
resolver = new TriggerValueResolver(resolver);
// TODO: add InvokeValueResolver
return(resolver);
}
public void VisitLambdaMethod(QNode node)
{
var right = this.ContextExpression.Pop();
var left = this.ContextExpression.Pop();
var method = EnumResolver.ResolveNodeType(node.Type);
var lambda = Expression.Lambda(right, this.ContextParameters.Peek());
var exp = this.BuildMethodCallExpression(method, left, lambda);
this.ContextExpression.Push(exp);
}
public void Resolver_Enum()
{
var resolver = new EnumResolver(NoneResolver.Instance);
DayOfWeek actual;
Assert.IsFalse(resolver.TryResolve(null, out actual));
Assert.IsFalse(resolver.TryResolve(Some, out actual));
var expected = DayOfWeek.Monday;
{
Assert.IsTrue(resolver.TryResolve(expected.ToString(), out actual));
Assert.AreEqual(expected, actual);
}
{
Assert.IsFalse(resolver.TryResolve(((int)expected).ToString(), out actual));
Assert.AreEqual(DayOfWeek.Sunday, actual);
}
}
public static void Accept(this QNode node, IQNodeVisitor visitor)
{
var group = EnumResolver.ResolveNodeGroup(node.Type);
if (group == NodeGroup.Binary)
{
AcceptBinary(node, visitor);
}
if (group == NodeGroup.Member)
{
AcceptMember(node, visitor);
}
if (group == NodeGroup.Querable)
{
AcceptQuerable(node, visitor);
}
if (group == NodeGroup.Method)
{
var method = EnumResolver.ResolveNodeType(node.Type);
if (method == NodeType.Select)
{
AcceptProjection(node, visitor);
}
else if (node.Argument == null)
{
AcceptEmptyMethod(node, visitor);
}
else
{
AcceptMethod(node, visitor);
}
}
if (group == NodeGroup.Constant)
{
AcceptConstant(node, visitor);
}
}
public static void Accept(this QNode node, IQNodeVisitor visitor)
{
if (node.Type == NodeType.Binary)
{
AcceptBinary(node, visitor);
}
if (node.Type == NodeType.Member)
{
AcceptMember(node, visitor);
}
if (node.Type == NodeType.Querable)
{
AcceptQuerable(node, visitor);
}
if (node.Type == NodeType.Method)
{
var method = EnumResolver.ResolveMethod(node.Value);
if (method == MethodType.Select)
{
AcceptProjection(node, visitor);
}
else if (node.Right == null)
{
AcceptEmptyMethod(node, visitor);
}
else
{
AcceptMethod(node, visitor);
}
}
if (node.Type == NodeType.Constant)
{
AcceptConstant(node, visitor);
}
}
private void Visit(QNode node)
{
var nodeType = EnumResolver.ResolveNodeType(node.Type);
var group = EnumResolver.ResolveNodeGroup(nodeType);
if (group == NodeGroup.Method)
{
if (nodeType == NodeType.QueryString)
{
this.QueryStringNode = node;
this.QueryStringParentNode = this.CurrentParentNode;
}
}
this.CurrentParentNode = node;
if (node.Operand != null)
{
this.Visit(node.Operand);
}
if (node.Argument != null)
{
this.Visit(node.Argument);
}
}
public void SetBinaryConstantConverter(QNode node)
{
var caller = this.ContextExpression.Peek();
var binaryType = EnumResolver.ResolveNodeType(node.Type);
switch (binaryType)
{
case NodeType.And:
case NodeType.Or:
break;
case NodeType.Equal:
case NodeType.GreaterThan:
case NodeType.GreaterThanOrEqual:
case NodeType.LessThan:
case NodeType.LessThanOrEqual:
case NodeType.NotEqual:
this.ConstantConverter = new DefaultConverter(caller.Type);
break;
default:
throw new NotImplementedException(binaryType.ToString());
}
}
/// <summary>
/// The visit method call.
/// </summary>
/// <param name="m">
/// The memberAccess.
/// </param>
/// <returns>
/// The <see cref="Expression" />.
/// </returns>
protected override Expression VisitMethodCall(MethodCallExpression m)
{
QNode node;
NodeType method;
if (NodeType.TryParse(m.Method.Name, out method))
{
node = new QNode()
{
Type = method
};
}
else
{
throw new Exception(m.Method.Name);
}
if (m.Object != null)
{
if (m.Arguments.Count > 0 && m.Arguments[0].NodeType == ExpressionType.MemberAccess)
{
if (typeof(IConstantPlaceHolder).IsAssignableFrom(
((MemberExpression)m.Arguments[0]).Expression.Type))
{
this.Visit(m.Object);
node.Operand = this.Context.Pop();
this.Visit(m.Arguments[0]);
node.Argument = this.Context.Pop();
}
else if (EnumResolver.ResolveNodeType(node.Type) == NodeType.Contains)
{
if (this.IsNot.Count > 0 && this.IsNot.Peek() == ExpressionType.Not)
{
node.Type = NodeType.NotIn;
this.IsNot.Pop();
}
else
{
node.Type = NodeType.In;
}
this.Visit(m.Arguments[0]);
node.Operand = this.Context.Pop();
this.Visit(m.Object);
node.Argument = this.Context.Pop();
}
}
else
{
this.Visit(m.Object);
node.Operand = this.Context.Pop();
if (m.Arguments.Count > 0)
{
this.Visit(m.Arguments[0]);
node.Argument = this.Context.Pop();
}
}
}
else
{
this.Visit(m.Arguments[0]);
node.Operand = this.Context.Pop();
if (m.Arguments.Count == 2)
{
this.Visit(m.Arguments[1]);
node.Argument = this.Context.Pop();
}
// QueryString
else if (m.Arguments.Count == 3)
{
this.Visit(m.Arguments[1]);
var queryString = this.Context.Pop();
this.Visit(m.Arguments[2]);
var fields = this.Context.Pop();
queryString.Argument = fields;
node.Argument = queryString;
}
}
this.Context.Push(node);
return(m);
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.RegisterModule(new FiberModule <DialogTask>());
// singleton components
builder
.Register(c => new ResourceManager("Microsoft.Bot.Builder.Resource.Resources", typeof(Resource.Resources).Assembly))
.As <ResourceManager>()
.SingleInstance();
// every lifetime scope is driven by a message
builder
.Register((c, p) => p.TypedAs <IMessageActivity>())
.AsSelf()
.AsImplementedInterfaces()
.InstancePerMatchingLifetimeScope(LifetimeScopeTag);
// make the address and cookie available for the lifetime scope
builder
.Register(c => Address.FromActivity(c.Resolve <IActivity>()))
.AsImplementedInterfaces()
.InstancePerMatchingLifetimeScope(LifetimeScopeTag);
builder
.RegisterType <ResumptionCookie>()
.AsSelf()
.InstancePerMatchingLifetimeScope(LifetimeScopeTag);
// components not marked as [Serializable]
builder
.RegisterType <MicrosoftAppCredentials>()
.AsSelf()
.SingleInstance();
builder
// not resolving IEqualityComparer<IAddress> from container because it's a very local policy
// and yet too broad of an interface. could explore using tags for registration overrides.
.Register(c => new LocalMutualExclusion <IAddress>(new ConversationAddressComparer()))
.As <IScope <IAddress> >()
.SingleInstance();
builder
.Register(c => new ConnectorClientFactory(c.Resolve <IAddress>(), c.Resolve <MicrosoftAppCredentials>()))
.As <IConnectorClientFactory>()
.InstancePerLifetimeScope();
builder
.Register(c => c.Resolve <IConnectorClientFactory>().MakeConnectorClient())
.As <IConnectorClient>()
.InstancePerLifetimeScope();
builder
.Register(c => c.Resolve <IConnectorClientFactory>().MakeStateClient())
.As <IStateClient>()
.InstancePerLifetimeScope();
builder
.Register(c => new DetectChannelCapability(c.Resolve <IAddress>()))
.As <IDetectChannelCapability>()
.InstancePerLifetimeScope();
builder
.Register(c => c.Resolve <IDetectChannelCapability>().Detect())
.As <IChannelCapability>()
.InstancePerLifetimeScope();
builder.RegisterType <ConnectorStore>()
.AsSelf()
.InstancePerLifetimeScope();
// If bot wants to use InMemoryDataStore instead of
// ConnectorStore, the below registration should be used
// as the inner IBotDataStore for CachingBotDataStore
/*builder.RegisterType<InMemoryDataStore>()
* .AsSelf()
* .SingleInstance(); */
builder.Register(c => new CachingBotDataStore(c.Resolve <ConnectorStore>(),
CachingBotDataStoreConsistencyPolicy.ETagBasedConsistency))
.As <IBotDataStore <BotData> >()
.AsSelf()
.InstancePerLifetimeScope();
builder
.RegisterType <JObjectBotData>()
.AsSelf()
.InstancePerLifetimeScope();
builder
.Register(c => new DialogTaskManagerBotDataLoader(c.Resolve <JObjectBotData>(),
c.Resolve <IDialogTaskManager>()))
.As <IBotData>()
.InstancePerLifetimeScope();
builder
.Register((c, p) => new BotDataBagStream(p.TypedAs <IBotDataBag>(), p.TypedAs <string>()))
.As <Stream>()
.InstancePerDependency();
builder
.Register(c => new DialogTaskManager(DialogModule.BlobKey,
c.Resolve <JObjectBotData>(),
c.Resolve <IStackStoreFactory <DialogTask> >(),
c.Resolve <Func <IDialogStack, CancellationToken, IDialogContext> >()))
.AsSelf()
.As <IDialogTaskManager>()
.InstancePerLifetimeScope();
builder
.RegisterType <DialogContext>()
.As <IDialogContext>()
.InstancePerDependency();
builder
.Register(c =>
{
var cc = c.Resolve <IComponentContext>();
Func <string, IBotDataBag, IStore <IFiberLoop <DialogTask> > > make = (taskId, botDataBag) =>
{
var stream = cc.Resolve <Stream>(TypedParameter.From(botDataBag), TypedParameter.From(taskId));
return(cc.Resolve <IStore <IFiberLoop <DialogTask> > >(TypedParameter.From(stream)));
};
return(make);
})
.As <Func <string, IBotDataBag, IStore <IFiberLoop <DialogTask> > > >()
.InstancePerDependency();
builder.Register(c => c.Resolve <IDialogTaskManager>().DialogTasks[0])
.As <IDialogStack>()
.As <IDialogTask>()
.InstancePerLifetimeScope();
// Scorable implementing "/deleteprofile"
builder
.Register(c => new Regex("^(\\s)*/deleteprofile", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace))
.Keyed <Regex>(Key_DeleteProfile_Regex)
.SingleInstance();
builder
.Register(c => new DeleteProfileScorable(c.Resolve <IDialogStack>(), c.Resolve <IBotData>(), c.Resolve <IBotToUser>(), c.ResolveKeyed <Regex>(Key_DeleteProfile_Regex)))
.As <IScorable <IActivity, double> >()
.InstancePerLifetimeScope();
builder
.Register(c =>
{
var cc = c.Resolve <IComponentContext>();
Func <IActivity, IResolver> make = activity =>
{
var resolver = NoneResolver.Instance;
resolver = new EnumResolver(resolver);
resolver = new AutofacResolver(cc, resolver);
resolver = new ArrayResolver(resolver,
activity,
cc.Resolve <IDialogStack>(),
cc.Resolve <IBotToUser>(),
cc.Resolve <IBotData>(),
cc.Resolve <IDialogTaskManager>());
resolver = new ActivityResolver(resolver);
return(resolver);
};
return(make);
})
.AsSelf()
.InstancePerLifetimeScope();
builder
.RegisterType <DialogRouter>()
.Keyed <IScorable <IActivity, double> >(Key_Dialog_Router)
.InstancePerLifetimeScope();
builder
.Register(c =>
{
var cc = c.Resolve <IComponentContext>();
Func <IPostToBot> makeInner = () =>
{
IPostToBot post = new ReactiveDialogTask(cc.Resolve <IDialogTask>(), cc.Resolve <Func <IDialog <object> > >());
post = new ScoringDialogTask <double>(post, cc.ResolveKeyed <IScorable <IActivity, double> >(Key_Dialog_Router));
return(post);
};
IPostToBot outer = new PersistentDialogTask(makeInner, cc.Resolve <IBotData>());
outer = new SerializingDialogTask(outer, cc.Resolve <IAddress>(), c.Resolve <IScope <IAddress> >());
outer = new ExceptionTranslationDialogTask(outer);
outer = new LocalizedDialogTask(outer);
outer = new PostUnhandledExceptionToUserTask(outer, cc.Resolve <IBotToUser>(), cc.Resolve <ResourceManager>(), cc.Resolve <TraceListener>());
outer = new LogPostToBot(outer, cc.Resolve <IActivityLogger>());
return(outer);
})
.As <IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterType <NullActivityLogger>()
.AsImplementedInterfaces()
.SingleInstance();
builder
.RegisterType <AlwaysSendDirect_BotToUser>()
.AsSelf()
.InstancePerLifetimeScope();
builder
.Register(c => new LogBotToUser(
new MapToChannelData_BotToUser(c.Resolve <AlwaysSendDirect_BotToUser>(), new [] { new KeyboardCardMapper() }),
c.Resolve <IActivityLogger>()))
.As <IBotToUser>()
.InstancePerLifetimeScope();
}
public FileResult Export(WorkerFilter filter)
{
var response = _workerService.Filter(filter);
var branches = _branchService.Filter(new BranchFilter()).Branches;
var csv = new CsvExport();
if (filter.IsReport)
{
csv.ConcatRow(0, "COMPAÑÍA,ID SUCURSAL,SUCURSAL,DEPARTAMENTO,PUESTO,CÓDIGO,NOMBRE,GÉNERO,NSS,FECHA CONSUMO,CONSUMIDO,RECOMENDADO");
foreach (var worker in response.Workers)
{
var today = DateTimeExtensions.Today();
var startDate = filter.Month.IsGreaterThanZero() ? new DateTime(today.Year, today.Month, 1).ConvertToString() : "";
var endDate = filter.Month.IsGreaterThanZero() ? new DateTime(today.Year, today.Month, DateTime.DaysInMonth(today.Year, today.Month)).ConvertToString() : "";;
var responseCalories = _reservationService.Report(new ReservationReport {
WorkerId = worker.Id, StartDate = startDate, EndDate = endDate
});
var currentCompany = branches.First(branch => branch.Id.IsEqualTo(worker.BranchId)).Company.Name;
//var responseCalories = new ReservationReportResponse
//{
// Calories = new List<ReservationCalorieReportResponse>
//{
// new ReservationCalorieReportResponse{Date = DateTimeExtensions.Today().AddDays(-7).ConvertToString(),Dinner = 200, Lunch = 1000, BreakFast = 150},
// new ReservationCalorieReportResponse{Date = DateTimeExtensions.Today().AddDays(-6).ConvertToString(),Dinner = 164, Lunch = 1000, BreakFast = 150},
// new ReservationCalorieReportResponse{Date = DateTimeExtensions.Today().AddDays(-5).ConvertToString(),Dinner = 195, Lunch = 1000, BreakFast = 150},
// new ReservationCalorieReportResponse{Date = DateTimeExtensions.Today().AddDays(-4).ConvertToString(),Dinner = 109, Lunch = 1000, BreakFast = 203},
// new ReservationCalorieReportResponse{Date = DateTimeExtensions.Today().AddDays(-3).ConvertToString(),Dinner = 287, Lunch = 1000, BreakFast = 343},
// new ReservationCalorieReportResponse{Date = DateTimeExtensions.Today().AddDays(-2).ConvertToString(),Dinner = 207, Lunch = 1000, BreakFast = 150},
// new ReservationCalorieReportResponse{Date = DateTimeExtensions.Today().AddDays(-1).ConvertToString(),Dinner = 218, Lunch = 1000, BreakFast = 145}
//}
//};
foreach (var calorie in responseCalories.Calories)
{
var sumCalories = calorie.BreakFast + calorie.Dinner + calorie.Lunch;
var row = string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11}", currentCompany, worker.BranchId, worker.Branch.Name, worker.Department.Name, worker.Job.Name, worker.Code, worker.FullName, EnumResolver.Gender(worker.Gender.GetValue()), worker.Imss, calorie.Date, sumCalories.RoundDecimal(), worker.LimitEnergy);
csv.ConcatRow(0, row);
}
}
}
else
{
csv.ConcatRow(0, "CÓDIGO,NOMBRE,APELLIDO,EMAIL,IMSS,GÉNERO,GAFFETE,INGESTA CALÓRICA,SUCURSAL,DEPARTAMENTO,PUESTO,ROL,ESTADO");
csv.ConcatRows(0, "Code,FirstName,LastName,Email,Imss,GenderLabel,Badge,LimitEnergy,Branch,Department,Job,Role,Status", response.Workers);
}
var stream = csv.RetrieveFile();
return(new StreamFactory().Csv(stream, "Ingesta calórica por colaborador"));
}
public void SetMethodConstantConverter(QNode node)
{
var caller = this.ContextExpression.Peek();
var methodType = EnumResolver.ResolveNodeType(node.Type);
switch (methodType)
{
case NodeType.Contains:
var containsMethod = caller.Type.GetMethod("Contains", new[] { typeof(string) });
if (containsMethod == null)
{
var toStringMethod = typeof(object).GetMethod("ToString", new Type[] {});
var exp1 = Expression.Call(caller, toStringMethod, null);
this.ContextExpression.Pop();
this.ContextExpression.Push(exp1);
if (this.Provider == ProviderEnum.EnumerableQueryProvider)
{
var exp2 = Expression.Call(exp1, Methods.ToLower, null);
this.ContextExpression.Pop();
this.ContextExpression.Push(exp2);
this.ConstantConverter = new ToLowerConverter(exp1.Type);
}
else
{
this.ConstantConverter = new DefaultConverter(exp1.Type);
}
}
else
{
if (this.Provider == ProviderEnum.EnumerableQueryProvider)
{
var exp1 = Expression.Call(caller, Methods.ToLower, null);
this.ContextExpression.Pop();
this.ContextExpression.Push(exp1);
this.ConstantConverter = new ToLowerConverter(caller.Type);
}
else
{
this.ConstantConverter = new DefaultConverter(caller.Type);
}
}
break;
case NodeType.StartsWith:
var startsWithMethod = caller.Type.GetMethod("StartsWith", new[] { typeof(string) });
if (startsWithMethod == null)
{
var toStringMethod = typeof(object).GetMethod("ToString", new Type[] { });
var exp1 = Expression.Call(caller, toStringMethod, null);
this.ContextExpression.Pop();
this.ContextExpression.Push(exp1);
this.ConstantConverter = new DefaultConverter(exp1.Type);
}
else
{
this.ConstantConverter = new DefaultConverter(caller.Type);
}
break;
case NodeType.EndsWith:
var endsWithMethod = caller.Type.GetMethod("EndsWith", new[] { typeof(string) });
if (endsWithMethod == null)
{
var toStringMethod = typeof(object).GetMethod("ToString", new Type[] { });
var exp1 = Expression.Call(caller, toStringMethod, null);
this.ContextExpression.Pop();
this.ContextExpression.Push(exp1);
this.ConstantConverter = new DefaultConverter(exp1.Type);
}
else
{
this.ConstantConverter = new DefaultConverter(caller.Type);
}
break;
case NodeType.In:
case NodeType.NotIn:
this.ConstantConverter = new ArrayConverter(caller.Type);
break;
case NodeType.Take:
case NodeType.Skip:
this.ConstantConverter = new IntegerConverter(caller.Type);
break;
default:
throw new NotImplementedException(methodType.ToString());
}
}
public void VisitMethod(QNode node)
{
Expression resultExpression;
var right = this.ContextExpression.Pop();
var left = this.ContextExpression.Pop();
var method = EnumResolver.ResolveNodeType(node.Type);
switch (method)
{
case NodeType.Contains:
if (left.Type != typeof(string))
{
left = Expression.Call(left, "ToString", null);
}
resultExpression = Expression.Call(left, Methods.Contains, (ConstantExpression)right);
break;
case NodeType.StartsWith:
if (left.Type != typeof(string))
{
left = Expression.Call(left, "ToString", null);
}
resultExpression = Expression.Call(left, Methods.StartsWith, (ConstantExpression)right);
break;
case NodeType.EndsWith:
if (left.Type != typeof(string))
{
left = Expression.Call(left, "ToString", null);
}
resultExpression = Expression.Call(left, Methods.EndsWith, (ConstantExpression)right);
break;
case NodeType.In:
var containsMethod = right.Type.GetTypeInfo().GetMethod("Contains");
resultExpression = Expression.Call(right, containsMethod, left);
break;
case NodeType.NotIn:
var containsMethod1 = right.Type.GetTypeInfo().GetMethod("Contains");
var call = Expression.Call(right, containsMethod1, left);
resultExpression = Expression.Not(call);
break;
case NodeType.Take:
var types = new List <Type>
{
left.Type.GetTypeInfo().IsGenericType
? left.Type.GenericTypeArguments[0]
: left.Type
};
resultExpression = Expression.Call(typeof(Queryable), "Take", types.ToArray(), left, right);
break;
case NodeType.Skip:
var types1 = new List <Type>
{
left.Type.GetTypeInfo().IsGenericType
? left.Type.GenericTypeArguments[0]
: left.Type
};
resultExpression = Expression.Call(typeof(Queryable), "Skip", types1.ToArray(), left, right);
break;
default:
throw new NotImplementedException(method.ToString());
}
this.ContextExpression.Push(resultExpression);
}
public void VisitBinary(QNode node)
{
var binary = EnumResolver.ResolveNodeType(node.Type);
switch (binary)
{
case NodeType.And:
{
var left = this.ContextQuery.Pop();
var right = this.ContextQuery.Pop();
this.ContextQuery.Push(left && right);
}
break;
case NodeType.Or:
{
var left = this.ContextQuery.Pop();
var right = this.ContextQuery.Pop();
this.ContextQuery.Push(left || right);
}
break;
case NodeType.Equal:
{
var field = this.ContextField.Pop();
var value = this.ContextValue.Pop();
var query = new MatchQuery {
Field = field, Query = value.ToString()
};
this.ContextQuery.Push(query);
}
break;
case NodeType.NotEqual:
{
var field = this.ContextField.Pop();
var value = this.ContextValue.Pop();
var query = new MatchQuery {
Field = field, Query = value.ToString()
};
this.ContextQuery.Push(!query);
}
break;
case NodeType.GreaterThan:
{
var field = this.ContextField.Pop();
var value = this.ContextValue.Pop();
var query = new TermRangeQuery {
Field = field, GreaterThan = value.ToString()
};
this.ContextQuery.Push(query);
}
break;
case NodeType.GreaterThanOrEqual:
{
var field = this.ContextField.Pop();
var value = this.ContextValue.Pop();
var query = new TermRangeQuery {
Field = field, GreaterThanOrEqualTo = value.ToString()
};
this.ContextQuery.Push(query);
}
break;
case NodeType.LessThan:
{
var field = this.ContextField.Pop();
var value = this.ContextValue.Pop();
var query = new TermRangeQuery {
Field = field, LessThan = value.ToString()
};
this.ContextQuery.Push(query);
}
break;
case NodeType.LessThanOrEqual:
{
var field = this.ContextField.Pop();
var value = this.ContextValue.Pop();
var query = new TermRangeQuery {
Field = field, LessThanOrEqualTo = value.ToString()
};
this.ContextQuery.Push(query);
}
break;
default:
throw new NotImplementedException(binary.ToString());
}
}
public static void Accept(this QNode node, QNodeConverter visitor)
{
var group = EnumResolver.ResolveNodeGroup(node.Type);
if (group == NodeGroup.Binary)
{
AcceptBinary(node, visitor);
}
if (group == NodeGroup.Member)
{
AcceptMember(node, visitor);
}
if (group == NodeGroup.Querable)
{
AcceptQuerable(node, visitor);
}
if (group == NodeGroup.Method)
{
var method = EnumResolver.ResolveNodeType(node.Type);
switch (method)
{
case NodeType.Select:
AcceptProjection(node, visitor);
break;
case NodeType.Where:
case NodeType.Any:
case NodeType.OrderBy:
case NodeType.OrderByDescending:
AcceptLambdaArgumentMethod(node, visitor);
break;
case NodeType.Contains:
case NodeType.In:
case NodeType.NotIn:
case NodeType.StartsWith:
case NodeType.EndsWith:
case NodeType.Take:
case NodeType.Skip:
AcceptValueArgumentMethod(node, visitor);
break;
case NodeType.ToString:
case NodeType.ToLower:
AcceptEmptyMethod(node, visitor);
break;
case NodeType.Count:
if (node.Argument == null)
{
AcceptEmptyMethod(node, visitor);
}
else
{
AcceptLambdaArgumentMethod(node, visitor);
}
break;
default:
throw new NotImplementedException(method.ToString());
}
}
if (group == NodeGroup.Constant)
{
AcceptConstant(node, visitor);
}
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.RegisterModule(new FiberModule <DialogTask>());
// singleton components
builder
.Register(c => new ResourceManager("Microsoft.Bot.Builder.Resource.Resources", typeof(Resource.Resources).Assembly))
.As <ResourceManager>()
.SingleInstance();
// every lifetime scope is driven by a message
builder
.Register((c, p) => p.TypedAs <IMessageActivity>())
.AsSelf()
.AsImplementedInterfaces()
.InstancePerMatchingLifetimeScope(LifetimeScopeTag);
// make the address and cookie available for the lifetime scope
builder
.Register(c => Address.FromActivity(c.Resolve <IActivity>()))
.AsImplementedInterfaces()
.InstancePerMatchingLifetimeScope(LifetimeScopeTag);
#pragma warning disable CS0618
builder
.RegisterType <ResumptionCookie>()
.AsSelf()
.InstancePerMatchingLifetimeScope(LifetimeScopeTag);
#pragma warning restore CS0618
builder
.Register(c => c.Resolve <IActivity>().ToConversationReference())
.AsSelf()
.InstancePerMatchingLifetimeScope(LifetimeScopeTag);
// components not marked as [Serializable]
builder
.RegisterType <MicrosoftAppCredentials>()
.AsSelf()
.SingleInstance();
builder
// not resolving IEqualityComparer<IAddress> from container because it's a very local policy
// and yet too broad of an interface. could explore using tags for registration overrides.
.Register(c => new LocalMutualExclusion <IAddress>(new ConversationAddressComparer()))
.As <IScope <IAddress> >()
.SingleInstance();
builder
.Register(c => new ConnectorClientFactory(c.Resolve <IAddress>(), c.Resolve <MicrosoftAppCredentials>()))
.As <IConnectorClientFactory>()
.ExternallyOwned();
builder
.Register(c => c.Resolve <IConnectorClientFactory>().MakeConnectorClient())
.As <IConnectorClient>()
.ExternallyOwned();
builder
.Register(c => c.Resolve <IConnectorClientFactory>().MakeStateClient())
.As <IStateClient>()
.ExternallyOwned();
builder
.RegisterType <ChannelCapability>()
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <ConnectorStore, IBotDataStore <BotData> >()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <InMemoryDataStore, IBotDataStore <BotData> >()
.SingleInstance();
builder
.RegisterKeyedType <CachingBotDataStore, IBotDataStore <BotData> >()
.WithParameter((pi, c) => pi.ParameterType == typeof(CachingBotDataStoreConsistencyPolicy),
(pi, c) => CachingBotDataStoreConsistencyPolicy.ETagBasedConsistency)
.InstancePerLifetimeScope();
builder
.RegisterAdapterChain <IBotDataStore <BotData> >
(
typeof(ConnectorStore),
typeof(CachingBotDataStore)
)
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <JObjectBotData, IBotData>()
.AsSelf()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <DialogTaskManagerBotDataLoader, IBotData>()
.InstancePerLifetimeScope();
builder
.RegisterAdapterChain <IBotData>
(
typeof(JObjectBotData),
typeof(DialogTaskManagerBotDataLoader)
)
.InstancePerLifetimeScope();
builder
.Register((c, p) => new BotDataBagStream(p.TypedAs <IBotDataBag>(), p.TypedAs <string>()))
.As <Stream>()
.InstancePerDependency();
builder
.Register(c => new DialogTaskManager(DialogModule.BlobKey,
c.Resolve <JObjectBotData>(),
c.Resolve <IStackStoreFactory <DialogTask> >(),
c.Resolve <Func <IDialogStack, CancellationToken, IDialogContext> >(),
c.Resolve <IEventProducer <IActivity> >()))
.AsSelf()
.As <IDialogTaskManager>()
.As <IDialogTasks>()
.InstancePerLifetimeScope();
builder
.RegisterType <DialogSystem>()
.As <IDialogSystem>();
builder
.RegisterType <DialogContext>()
.As <IDialogContext>()
.InstancePerDependency();
builder
.Register(c =>
{
var cc = c.Resolve <IComponentContext>();
Func <string, IBotDataBag, IStore <IFiberLoop <DialogTask> > > make = (taskId, botDataBag) =>
{
var stream = cc.Resolve <Stream>(TypedParameter.From(botDataBag), TypedParameter.From(taskId));
return(cc.Resolve <IStore <IFiberLoop <DialogTask> > >(TypedParameter.From(stream)));
};
return(make);
})
.As <Func <string, IBotDataBag, IStore <IFiberLoop <DialogTask> > > >()
.InstancePerDependency();
builder.Register(c => c.Resolve <IDialogTaskManager>().DialogTasks[0])
.As <IDialogStack>()
.As <IDialogTask>()
.InstancePerLifetimeScope();
// Scorable implementing "/deleteprofile"
builder
.Register(c => new Regex("^(\\s)*/deleteprofile", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace))
.Keyed <Regex>(Key_DeleteProfile_Regex)
.SingleInstance();
builder
.Register(c => new DeleteProfileScorable(c.Resolve <IDialogStack>(), c.Resolve <IBotData>(), c.Resolve <IBotToUser>(), c.ResolveKeyed <Regex>(Key_DeleteProfile_Regex)))
.As <IScorable <IActivity, double> >()
.InstancePerLifetimeScope();
// scorable implementing "end conversation"
builder
.RegisterInstance(EndConversationEvent.MakeScorable())
.As <IScorable <IResolver, double> >()
.SingleInstance();
builder
.Register(c =>
{
var cc = c.Resolve <IComponentContext>();
Func <IActivity, IResolver> make = activity =>
{
var resolver = NoneResolver.Instance;
resolver = new EnumResolver(resolver);
resolver = new AutofacResolver(cc, resolver);
resolver = new ArrayResolver(resolver,
activity,
cc.Resolve <IBotToUser>(),
cc.Resolve <IBotData>(),
cc.Resolve <IDialogSystem>());
resolver = new ActivityResolver(resolver);
resolver = new EventActivityValueResolver(resolver);
resolver = new InvokeActivityValueResolver(resolver);
return(resolver);
};
return(make);
})
.AsSelf()
.InstancePerLifetimeScope();
builder
.RegisterType <DialogRouter>()
.Keyed <IScorable <IActivity, double> >(Key_Dialog_Router)
.InstancePerLifetimeScope();
builder
.RegisterType <EventQueue <IActivity> >()
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
builder
.RegisterType <ReactiveDialogTask>()
.AsSelf()
.InstancePerLifetimeScope();
builder
.Register(c => new ScoringEventLoop <double>(c.Resolve <ReactiveDialogTask>(), c.Resolve <ReactiveDialogTask>(), c.Resolve <IEventConsumer <IActivity> >(), c.ResolveKeyed <IScorable <IActivity, double> >(Key_Dialog_Router)))
.As <IEventLoop>()
.InstancePerLifetimeScope();
// register IDataBag that is used for to load/save ResumptionData
builder
.Register(c =>
{
var cc = c.Resolve <IComponentContext>();
Func <IBotDataBag> make = () =>
{
return(cc.Resolve <IBotData>().PrivateConversationData);
};
return(make);
})
.As <Func <IBotDataBag> >()
.InstancePerLifetimeScope();
builder
.RegisterType <ResumptionContext>()
.AsSelf()
.InstancePerLifetimeScope();
builder
.RegisterType <LocaleFinder>()
.AsSelf()
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
// IPostToBot services
builder
.RegisterKeyedType <NullPostToBot, IPostToBot>()
.SingleInstance();
builder
.RegisterKeyedType <PassPostToBot, IPostToBot>()
.InstancePerDependency();
builder
.RegisterKeyedType <EventLoopDialogTask, IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <PersistentDialogTask, IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <ExceptionTranslationDialogTask, IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <SerializeByConversation, IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <SetAmbientThreadCulture, IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <PostUnhandledExceptionToUser, IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <LogPostToBot, IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <QueueDrainingDialogTask, IPostToBot>()
.InstancePerLifetimeScope();
builder
.RegisterAdapterChain <IPostToBot>
(
typeof(EventLoopDialogTask),
typeof(SetAmbientThreadCulture),
typeof(QueueDrainingDialogTask),
typeof(PersistentDialogTask),
typeof(ExceptionTranslationDialogTask),
typeof(SerializeByConversation),
typeof(PostUnhandledExceptionToUser),
typeof(LogPostToBot)
)
.InstancePerLifetimeScope();
// other
builder
.RegisterType <NullActivityLogger>()
.AsImplementedInterfaces()
.SingleInstance();
builder
.RegisterType <KeyboardCardMapper>()
.AsImplementedInterfaces()
.SingleInstance();
builder
.RegisterType <SetLocalTimestampMapper>()
.AsImplementedInterfaces()
.SingleInstance();
// IBotToUser services
builder
.RegisterType <InputHintQueue>()
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <NullBotToUser, IBotToUser>()
.SingleInstance();
builder
.RegisterKeyedType <PassBotToUser, IBotToUser>()
.InstancePerDependency();
builder
.RegisterKeyedType <AlwaysSendDirect_BotToUser, IBotToUser>()
.AsSelf()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <AutoInputHint_BotToUser, IBotToUser>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <MapToChannelData_BotToUser, IBotToUser>()
.InstancePerLifetimeScope();
builder
.RegisterKeyedType <LogBotToUser, IBotToUser>()
.InstancePerLifetimeScope();
#pragma warning disable CS1587
/// <see cref="LogBotToUser"/> is composed around <see cref="MapToChannelData_BotToUser"/> is composed around
/// <see cref="AlwaysSendDirect_BotToUser"/>. The complexity of registering each component is pushed to a separate
/// registration method, and each of these components are replaceable without re-registering
/// the entire adapter chain by registering a new component with the same component key.
#pragma warning restore CS1587
builder
.RegisterAdapterChain <IBotToUser>
(
typeof(AlwaysSendDirect_BotToUser),
typeof(AutoInputHint_BotToUser),
typeof(MapToChannelData_BotToUser),
typeof(LogBotToUser)
)
.InstancePerLifetimeScope();
}
private static string ExtractValue <T>(string property, T objectRetrieved)
{
property = property.Trim();
var valueRetrieved = objectRetrieved.ExtractProperty(property);
var valueString = String.Empty;
if (valueRetrieved.IsNotNull())
{
switch (property)
{
case "Region":
case "Company":
case "Branch":
case "Disease":
case "IngredientGroup":
case "Dealer":
case "Department":
case "Job":
case "Saucer":
case "Role":
valueString = valueRetrieved.ExtractName();
break;
case "Protein":
case "Carbohydrate":
case "Sugar":
case "Lipid":
case "Sodium":
case "NetWeight":
valueString = String.Format("{0}{1}", valueRetrieved, DisplayConstants.Gram);
break;
case "Badge":
case "Code":
case "Imss":
valueString = String.Format(" [{0}] ", valueRetrieved);
break;
case "Saucers":
case "Dealers":
valueString = valueRetrieved.ExtractNames();
break;
case "Energy":
case "LimitEnergy":
valueString = String.Format("{0} {1}", valueRetrieved, DisplayConstants.KiloCalorie);
break;
case "Status":
valueString = EnumResolver.Status(Convert.ToBoolean(valueRetrieved));
break;
case "Gender":
valueString = EnumResolver.Gender(GenderType.Male.GetValue());
break;
case "SaucerConfigurations":
valueString = valueRetrieved.ExtractTotalAmounts();
break;
case "SaucerMultimedias":
valueString = valueRetrieved.ExtractPaths();
break;
default:
valueString = valueRetrieved.ToString();
break;
}
}
return(valueString.Replace(",", " "));
}
private BindingHelper()
{
RegisterDefaultConverters();
Enums = new EnumResolver(() => OnPropertyChanged(nameof(Enums)));
DynamicBindings = new DPResolver(() => OnPropertyChanged(nameof(DynamicBindings)));
}
public void VisitMethod(QNode node)
{
var method = EnumResolver.ResolveNodeType(node.Type);
switch (method)
{
case NodeType.OrderBy:
case NodeType.OrderByDescending:
var member = this.ContextField.Pop();
var query = this.ContextQuery.Pop();
this.SortingRequest.Add(new KeyValuePair <Field, NodeType>(member, method));
break;
case NodeType.Where:
break;
case NodeType.Contains:
{
var value = string.Format("*{0}*", this.ContextValue.Pop());
var term = new QueryStringQuery {
DefaultField = this.ContextField.Pop(), Query = value
};
this.ContextQuery.Push(term);
}
break;
case NodeType.StartsWith:
{
var term = new PrefixQuery {
Field = this.ContextField.Pop(), Value = this.ContextValue.Pop()
};
this.ContextQuery.Push(term);
}
break;
case NodeType.EndsWith:
{
var value = string.Format("*{0}", this.ContextValue.Pop());
var term = new WildcardQuery {
Field = this.ContextField.Pop(), Value = value
};
this.ContextQuery.Push(term);
}
break;
case NodeType.In:
{
var value = this.ContextValue.Pop() as List <string>;
var terms = new TermsQuery {
Field = this.ContextField.Pop(), Terms = value
};
this.ContextQuery.Push(terms);
}
break;
case NodeType.NotIn:
{
var value = this.ContextValue.Pop() as List <string>;
var terms = !new TermsQuery {
Field = this.ContextField.Pop(), Terms = value
};
this.ContextQuery.Push(terms);
}
break;
default:
throw new NotImplementedException(method.ToString());
}
}