/// <summary>
/// Method to execute the task which is to collect the flight class.
/// </summary>
/// <remarks>Method gets FlightInfoAccessor in order to save the previous waterfall step result as departure date on ending point airport and then sets the FlightInfoAccessor.</remarks>
/// <param name="stepContext"></param>
/// <param name="cancellationToken"></param>
/// <returns>ClassChoice ChoicePrompt</returns>
private async Task <DialogTurnResult> ClassChoiceAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
FlightInfo flightInfo = await _accessor.FlightInfoAccessor.GetAsync(stepContext.Context, () => new FlightInfo());
if (flightInfo.OneWayFlight)
{
flightInfo.EndDate = null;
await _accessor.FlightInfoAccessor.SetAsync(stepContext.Context, flightInfo);
}
else
{
DateTimeResolution resolution = (stepContext.Result as IList <DateTimeResolution>)[0];
flightInfo.EndDate = resolution.Value;
await _accessor.FlightInfoAccessor.SetAsync(stepContext.Context, flightInfo);
}
return(await stepContext.PromptAsync("ClassChoice", new PromptOptions
{
Prompt = MessageFactory.Text("Please choose flight class (to access more details type in 'more flight'):"),
RetryPrompt = MessageFactory.Text("I don't recognize this option. Try again"),
Choices = ChoiceFactory.ToChoices(new List <string> {
"Standard", "Business", "Premium"
})
},
cancellationToken));
}
private static DateTimeResolution ReadResolution(IDictionary <string, string> resolution)
{
var result = new DateTimeResolution();
if (resolution.TryGetValue("timex", out var timex))
{
result.Timex = timex;
}
if (resolution.TryGetValue("value", out var value))
{
result.Value = value;
}
if (resolution.TryGetValue("start", out var start))
{
result.Start = start;
}
if (resolution.TryGetValue("end", out var end))
{
result.End = end;
}
return(result);
}
public static DayOfWeek GetDayOfWeek(this string datetime)
{
DayOfWeek? day;
DateTimeResolution resolution;
if (DateTimeResolution.TryParse(datetime, out resolution))
{
day = resolution.DayOfWeek;
DayOfWeek dayOfWeek;
if (day != null)
{
dayOfWeek = day.Value;
}
else
{
if (resolution.Year.HasValue && resolution.Month.HasValue && resolution.Day.HasValue)
{
dayOfWeek = new DateTime(resolution.Year.Value, resolution.Month.Value, resolution.Day.Value).DayOfWeek;
}
else
{
dayOfWeek = DateTime.Now.DayOfWeek;
}
}
return(dayOfWeek);
}
else
{
return(DateTime.Now.DayOfWeek);
}
}
/// <summary>Validates whether the reservation date is appropriate.</summary>
/// <param name="promptContext">The validation context.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects
/// or threads to receive notice of cancellation.</param>
/// <returns>A task that represents the work queued to execute.</returns>
/// <remarks>Reservations must be made at least an hour in advance.
/// If the task is successful, the result indicates whether the input was valid.</remarks>
private async Task <bool> DateValidatorAsync(
PromptValidatorContext <IList <DateTimeResolution> > promptContext,
CancellationToken cancellationToken = default(CancellationToken))
{
// Check whether the input could be recognized as an integer.
if (!promptContext.Recognized.Succeeded)
{
await promptContext.Context.SendActivityAsync(
"I'm sorry, I do not understand. Please enter the date or time for your reservation.",
cancellationToken : cancellationToken);
return(false);
}
// Check whether any of the recognized date-times are appropriate,
// and if so, return the first appropriate date-time.
DateTime earliest = DateTime.Now.AddHours(1.0);
DateTimeResolution value = promptContext.Recognized.Value.FirstOrDefault(v =>
DateTime.TryParse(v.Value ?? v.Start, out DateTime time) && DateTime.Compare(earliest, time) <= 0);
if (value != null)
{
promptContext.Recognized.Value.Clear();
promptContext.Recognized.Value.Add(value);
return(true);
}
await promptContext.Context.SendActivityAsync(
"I'm sorry, we can't take reservations earlier than an hour from now.",
cancellationToken : cancellationToken);
return(false);
}
/// <summary>
/// Truncates a DateTime value to the nearest partial value.
/// </summary>
/// <remarks>
/// From: http://stackoverflow.com/questions/1004698/how-to-truncate-milliseconds-off-of-a-net-datetime
/// </remarks>
/// <param name="date"></param>
/// <param name="resolution"></param>
/// <returns></returns>
public static DateTime Truncate(DateTime date, DateTimeResolution resolution = DateTimeResolution.Second)
{
switch (resolution)
{
case DateTimeResolution.Year:
return(new DateTime(date.Year, 1, 1, 0, 0, 0, 0, date.Kind));
case DateTimeResolution.Month:
return(new DateTime(date.Year, date.Month, 1, 0, 0, 0, date.Kind));
case DateTimeResolution.Day:
return(new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, date.Kind));
case DateTimeResolution.Hour:
return(date.AddTicks(-(date.Ticks % TimeSpan.TicksPerHour)));
case DateTimeResolution.Minute:
return(date.AddTicks(-(date.Ticks % TimeSpan.TicksPerMinute)));
case DateTimeResolution.Second:
return(date.AddTicks(-(date.Ticks % TimeSpan.TicksPerSecond)));
case DateTimeResolution.Millisecond:
return(date.AddTicks(-(date.Ticks % TimeSpan.TicksPerMillisecond)));
case DateTimeResolution.Tick:
return(date.AddTicks(0));
default:
throw new ArgumentException("unrecognized resolution", "resolution");
}
}
public MarcarConsulta()
{
dialogos = new DialogSet();
dialogos.Add("marcarConsulta", new WaterfallStep[] {
async(dc, args, next) =>
{
await dc.Prompt("capturaTexto", "Qual o seu nome ?");
},
async(dc, args, next) =>
{
nomeCliente = ((TextResult)args).Value;
await dc.Prompt("capturaTexto", $"{nomeCliente}, qual o convênio ?");
},
async(dc, args, next) =>
{
convenio = ((TextResult)args).Value;
await dc.Prompt("capturaDataHora", "Certo... Qual o dia e horário ?");
},
async(dc, args, next) =>
{
DateTimeResolution resultado = ((DateTimeResult)args).Resolution.First();
dataHora = Convert.ToDateTime(resultado.Value);
await dc.Context.SendActivity($"Está marcado. Dia {dataHora.ToString("dd/MM/yyyy HH:mm:ss")}");
await dc.End();
},
});
dialogos.Add("capturaDataHora", new Microsoft.Bot.Builder.Dialogs.DateTimePrompt(Culture.Portuguese));
dialogos.Add("capturaTexto", new Microsoft.Bot.Builder.Dialogs.TextPrompt());
}
public void Luis_Resolution_DateTime_Parse()
{
foreach (var test in TestCases)
{
DateTimeResolution actual;
Assert.IsTrue(DateTimeResolution.TryParse(test.Text, out actual), test.Text);
Assert.AreEqual(test.Resolution, actual, test.Text);
}
}
public Condition(string fieldName, CompareOperator compare, DateTime value, DateTimeResolution resolution)
{
FieldName = fieldName;
Operator = compare;
Value = value;
DateTimeResolution = resolution;
Negate = false;
AndConditions = new List <Condition>();
OrConditions = new List <Condition>();
}
private async Task <DialogTurnResult> PromptForLocationAsync(
WaterfallStepContext stepContext,
CancellationToken cancellationToken = default(CancellationToken))
{
EventParams eventParams = await _accessors.EventParamState.GetAsync(stepContext.Context);
string city = eventParams.City;
if (stepContext.Result != null)
{
DateTimeResolution resolution = (stepContext.Result as IList <DateTimeResolution>).First();
if (resolution.Value != null)
{
eventParams.StartDate = resolution.Value;
eventParams.EndDate = resolution.Value;
}
else
{
eventParams.StartDate = resolution.Start;
eventParams.EndDate = resolution.End;
}
}
await _accessors.EventParamState.SetAsync(stepContext.Context, eventParams);
if (city != null)
{
return(await stepContext.NextAsync());
}
var reply = stepContext.Context.Activity.CreateReply();
if (stepContext.Context.Activity.ChannelId == Microsoft.Bot.Connector.Channels.Facebook)
{
var channelData = JObject.FromObject(new { quick_replies = new dynamic[] { new { content_type = "location" } } });
reply.ChannelData = channelData;
reply.Text = "Give up a city or send your location to find events nearby.";
}
else
{
reply.Text = "Give up a city where the event should take place.";
}
return(await stepContext.PromptAsync(
LocationPrompt,
new PromptOptions
{
Prompt = reply,
RetryPrompt = MessageFactory.Text("I did not manage to process your location. Please give up a city."),
},
cancellationToken));
}
private Task CustomValidator(ITurnContext turnContext, PromptValidatorContext <IList <DateTimeResolution> > prompt, CancellationToken cancellationToken)
{
if (prompt.Recognized.Succeeded)
{
var resolution = prompt.Recognized.Value.First();
// re-write the resolution to just include the date part.
var rewrittenResolution = new DateTimeResolution
{
Timex = resolution.Timex.Split('T')[0],
Value = resolution.Value.Split(' ')[0]
};
prompt.End(new List <DateTimeResolution> {
rewrittenResolution
});
}
return(Task.CompletedTask);
}
private async Task <bool> DateValidatorAsync(
PromptValidatorContext <IList <DateTimeResolution> > promptContext,
CancellationToken cancellationToken = default(CancellationToken))
{
if (!promptContext.Recognized.Succeeded)
{
await promptContext.Context.SendActivityAsync(
"Please enter a date of time for your event.",
cancellationToken : cancellationToken);
return(false);
}
DateTimeResolution value = promptContext.Recognized.Value.FirstOrDefault();
return(true);
}
private Task <bool> CustomValidator(PromptValidatorContext <IList <DateTimeResolution> > prompt, CancellationToken cancellationToken)
{
if (prompt.Recognized.Succeeded)
{
var resolution = prompt.Recognized.Value.First();
// re-write the resolution to just include the date part.
var rewrittenResolution = new DateTimeResolution
{
Timex = resolution.Timex.Split('T')[0],
Value = resolution.Value.Split(' ')[0]
};
prompt.Recognized.Value = new List <DateTimeResolution> {
rewrittenResolution
};
return(Task.FromResult(true));
}
return(Task.FromResult(false));
}
/// <summary>
/// Method to execute the task which is to collect the date of return from ending point airport.
/// </summary>
/// <remarks>Method gets FlightInfoAccessor in order to save the previous waterfall step result as departure date on starting point airport and then sets the FlightInfoAccessor.</remarks>
/// <param name="stepContext"></param>
/// <param name="cancellationToken"></param>
/// <returns>EndDate DateTimePrompt</returns>
private async Task <DialogTurnResult> GetEndDateAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
DateTimeResolution resolution = (stepContext.Result as IList <DateTimeResolution>)[0];
FlightInfo flightInfo = await _accessor.FlightInfoAccessor.GetAsync(stepContext.Context, () => new FlightInfo());
flightInfo.StartDate = resolution.Value;
await _accessor.FlightInfoAccessor.SetAsync(stepContext.Context, flightInfo);
//This block redirects to the next step if return date is not needed or ask for return date.
if (flightInfo.OneWayFlight)
{
return(await stepContext.NextAsync());
}
else
{
return(await stepContext.PromptAsync("EndDate", new PromptOptions
{
Prompt = MessageFactory.Text("Please enter date of return.")
},
cancellationToken));
}
}
/// <summary>Third step of the main dialog: return the collected party size and reservation date.</summary>
/// <param name="stepContext">The context for the waterfall step.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects
/// or threads to receive notice of cancellation.</param>
/// <returns>A task that represents the work queued to execute.</returns>
/// <remarks>If the task is successful, the result contains information from this step.</remarks>
private async Task <DialogTurnResult> AcknowledgeReservationAsync(
WaterfallStepContext stepContext,
CancellationToken cancellationToken = default(CancellationToken))
{
// Retrieve the reservation date.
DateTimeResolution resolution = (stepContext.Result as IList <DateTimeResolution>).First();
string time = resolution.Value ?? resolution.Start;
// Send an acknowledgement to the user.
await stepContext.Context.SendActivityAsync(
"Thank you. We will confirm your reservation shortly.",
cancellationToken : cancellationToken);
// Return the collected information to the parent context.
Reservation reservation = new Reservation
{
Date = time,
Size = (int)stepContext.Values["size"],
};
return(await stepContext.EndDialogAsync(reservation, cancellationToken));
}
/// <summary>
/// Interpret a parsed DateTimeResolution to provide a series of DateTime ranges
/// </summary>
/// <param name="resolution">The DateTimeResolution parsed from a LUIS response.</param>
/// <param name="now">The reference point of "now".</param>
/// <param name="calendar">The calendar to use for date math.</param>
/// <param name="rule">The calendar week rule to use for date math.</param>
/// <param name="firstDayOfWeek">The first day of the week to use for date math.</param>
/// <param name="HourFor">The hour that corresponds to the <see cref="DayPart"/> enumeration.</param>
/// <returns>A potentially infinite series of DateTime ranges.</returns>
public static IEnumerable <Range <DateTime> > Interpret(DateTimeResolution resolution, DateTime now, Calendar calendar, CalendarWeekRule rule, DayOfWeek firstDayOfWeek, Func <DayPart, int> HourFor)
{
// remove any millisecond components
now = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Kind);
switch (resolution.Reference)
{
case Reference.PAST_REF:
yield return(Range.From(DateTime.MinValue, now));
yield break;
case Reference.PRESENT_REF:
yield return(Range.From(now, now));
yield break;
case Reference.FUTURE_REF:
yield return(Range.From(now, DateTime.MaxValue));
yield break;
case null:
break;
default:
throw new NotImplementedException();
}
var start = now;
// TODO: maybe clamp to prevent divergence
while (start < DateTime.MaxValue)
{
var after = start;
while (true)
{
// for each date component in decreasing order of significance:
// if it's not a variable (-1) or missing (null) component, then
// add a unit of that component to "start"
// round down to the component's granularity
// calculate the "after" based on the size of that component
if (resolution.Year >= 0)
{
bool need = start.Year != resolution.Year;
if (need)
{
start = start.AddYears(1);
start = new DateTime(start.Year, 1, 1, 0, 0, 0, 0, start.Kind);
}
if (start.Year > resolution.Year)
{
yield break;
}
after = start.AddYears(1);
if (need)
{
continue;
}
}
if (resolution.Month >= 0)
{
bool need = start.Month != resolution.Month;
if (need)
{
start = start.AddMonths(1);
start = new DateTime(start.Year, start.Month, 1, 0, 0, 0, 0, start.Kind);
}
after = start.AddMonths(1);
if (need)
{
continue;
}
}
var week = calendar.GetWeekOfYear(start, rule, firstDayOfWeek);
if (resolution.Week >= 0)
{
bool need = week != resolution.Week;
if (need)
{
start = start.AddDays(7);
start = new DateTime(start.Year, start.Month, start.Day, 0, 0, 0, 0, start.Kind);
while (start.DayOfWeek != firstDayOfWeek)
{
start = start.AddDays(-1);
}
}
after = start.AddDays(7);
if (need)
{
continue;
}
}
if (resolution.DayOfWeek != null)
{
bool need = start.DayOfWeek != resolution.DayOfWeek;
if (need)
{
start = start.AddDays(1);
start = new DateTime(start.Year, start.Month, start.Day, 0, 0, 0, 0, start.Kind);
}
after = start.AddDays(1);
if (need)
{
continue;
}
}
if (resolution.Day >= 0)
{
bool need = start.Day != resolution.Day;
if (need)
{
start = start.AddDays(1);
start = new DateTime(start.Year, start.Month, start.Day, 0, 0, 0, 0, start.Kind);
}
after = start.AddDays(1);
if (need)
{
continue;
}
}
if (resolution.DayPart != null)
{
var hourStart = HourFor(resolution.DayPart.Value);
var hourAfter = HourFor(resolution.DayPart.Value.Next());
var hourDelta = hourAfter - hourStart;
if (hourDelta < 0)
{
hourDelta += 24;
}
bool need = start.Hour != hourStart;
if (need)
{
start = start.AddHours(1);
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, 0, 0, 0, start.Kind);
}
after = start.AddHours(hourDelta);
if (need)
{
continue;
}
}
if (resolution.Hour >= 0)
{
bool need = start.Hour != resolution.Hour;
if (need)
{
start = start.AddHours(1);
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, 0, 0, 0, start.Kind);
}
after = start.AddHours(1);
if (need)
{
continue;
}
}
if (resolution.Minute >= 0)
{
bool need = start.Minute != resolution.Minute;
if (need)
{
start = start.AddMinutes(1);
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, 0, 0, start.Kind);
}
after = start.AddMinutes(1);
if (need)
{
continue;
}
}
if (resolution.Second >= 0)
{
bool need = start.Second != resolution.Second;
if (need)
{
start = start.AddSeconds(1);
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second, 0, start.Kind);
}
after = start.AddSeconds(1);
if (need)
{
continue;
}
}
// if all of the components were variable or missing,
// then in order of increasing component granularity,
// if the component is variable rather than missing, then increment by that granularity
if (start == after)
{
if (resolution.Second < 0)
{
after = start.AddSeconds(1);
}
else if (resolution.Minute < 0)
{
after = start.AddMinutes(1);
}
else if (resolution.Hour < 0)
{
after = start.AddHours(1);
}
else if (resolution.Day < 0)
{
after = start.AddDays(1);
}
else if (resolution.Week < 0)
{
after = start.AddDays(7);
}
else if (resolution.Month < 0)
{
after = start.AddMonths(1);
}
else if (resolution.Year < 0)
{
after = start.AddYears(1);
}
else
{
// a second is our minimum granularity
after = start.AddSeconds(1);
}
}
if (start >= now)
{
yield return(new Range <DateTime>(start, after));
}
start = after;
}
}
}
/// <summary>
/// Compares two date time instances down to the millisecond
/// </summary>
/// <param name="dateTime"></param>
/// <param name="compareDateTime"></param>
/// <param name="resolution"></param>
/// <returns></returns>
public static bool IsEqualTo(this DateTime dateTime, DateTime compareDateTime, DateTimeResolution resolution = DateTimeResolution.Millisecond)
{
switch (resolution)
{
case DateTimeResolution.Millisecond:
if (dateTime.Millisecond != compareDateTime.Millisecond)
{
return false;
}
goto case DateTimeResolution.Second;
case DateTimeResolution.Second:
if (dateTime.Second != compareDateTime.Second)
{
return false;
}
goto case DateTimeResolution.Minute;
case DateTimeResolution.Minute:
if (dateTime.Minute != compareDateTime.Minute)
{
return false;
}
goto case DateTimeResolution.Hour;
case DateTimeResolution.Hour:
if (dateTime.Hour != compareDateTime.Hour)
{
return false;
}
goto case DateTimeResolution.Date;
case DateTimeResolution.Date:
if (dateTime.Date != compareDateTime.Date)
{
return false;
}
break;
case DateTimeResolution.Month:
if (dateTime.Month != compareDateTime.Month)
{
return false;
}
goto case DateTimeResolution.Year;
case DateTimeResolution.Year:
if (dateTime.Year != compareDateTime.Year)
{
return false;
}
break;
case DateTimeResolution.Week:
if (dateTime.Year != compareDateTime.Year)
{
return false;
}
int diff = dateTime.DayOfYear - compareDateTime.DayOfYear;
if (diff < -6 || diff > 6)
{
return false;
}
if (diff < 0 && 6 - (int)dateTime.DayOfWeek > Math.Abs(diff))
{
return false;
}
if (diff > 0 && diff > 6 - (int)compareDateTime.DayOfWeek)
{
return false;
}
break;
}
return true;
}
public string ToSqlString()
{
StringBuilder sql = new StringBuilder();
if (Negate)
{
sql.Append("not ");
}
if (AndConditions.Count > 0) // Omslut alla och:ar med en parentes, bara för att expliciera...
{
string sAnd = "";
foreach (Condition andCondition in AndConditions)
{
sql.Append(sAnd + andCondition.ToSqlString());
sAnd = " and ";
}
}
else if (OrConditions.Count > 0)
{
sql.Append("(");
string sOr = "";
foreach (Condition orCondition in OrConditions)
{
sql.Append(sOr + orCondition.ToSqlString());
sOr = " or ";
}
sql.Append(")");
}
else
{
if (Value == null)
{
sql.Append(FieldName);
if (Operator == CompareOperator.EqualTo)
{
sql.Append(" is null");
}
else if (Operator == CompareOperator.NotEqualTo)
{
sql.Append(" is not null");
}
else
{
throw new InvalidOperationException("Cannot compare null with anything else than Equal To (=) or Not Equal To (<>).");
}
}
else if (!(Value is DateTime) || (Value is DateTime && DateTimeResolution == DateTimeResolution.Exact))
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(Operator));
sql.Append(DatabaseValue);
}
else // Om det är DateTime med specialupplösning
{
DateTime v = (DateTime)Value;
if (DateTimeResolution == DateTimeResolution.Day)
{
if (Operator == CompareOperator.LessThan)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + v.ToString("yyyy-MM-dd") + "'");
}
if (Operator == CompareOperator.LessThanOrEqualTo)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + v.AddDays(1).ToString("yyyy-MM-dd") + "'");
}
if (Operator == CompareOperator.EqualTo)
{
sql.Append("(");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + v.ToString("yyyy-MM-dd") + "'");
sql.Append(" and ");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + v.AddDays(1).ToString("yyyy-MM-dd") + "'");
sql.Append(")");
}
if (Operator == CompareOperator.GreaterThanOrEqualTo)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + v.ToString("yyyy-MM-dd") + "'");
}
if (Operator == CompareOperator.GreaterThan)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + v.AddDays(1).ToString("yyyy-MM-dd") + "'");
}
if (Operator == CompareOperator.NotEqualTo)
{
sql.Append("(");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + v.ToString("yyyy-MM-dd") + "'");
sql.Append(" or ");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + v.AddDays(1).ToString("yyyy-MM-dd") + "'");
sql.Append(")");
}
}
else if (DateTimeResolution == DateTimeResolution.Minute)
{
if (Operator == CompareOperator.LessThan)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + v.ToString("yyyy-MM-dd HH:mm") + "'");
}
if (Operator == CompareOperator.LessThanOrEqualTo)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + v.AddDays(1).ToString("yyyy-MM-dd HH:mm") + "'");
}
if (Operator == CompareOperator.EqualTo)
{
sql.Append("(");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + v.ToString("yyyy-MM-dd HH:mm") + "'");
sql.Append(" and ");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + v.AddDays(1).ToString("yyyy-MM-dd HH:mm") + "'");
sql.Append(")");
}
if (Operator == CompareOperator.GreaterThanOrEqualTo)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + v.ToString("yyyy-MM-dd HH:mm") + "'");
}
if (Operator == CompareOperator.GreaterThan)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + v.AddDays(1).ToString("yyyy-MM-dd HH:mm") + "'");
}
if (Operator == CompareOperator.NotEqualTo)
{
sql.Append("(");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + v.ToString("yyyy-MM-dd HH:mm") + "'");
sql.Append(" or ");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + v.AddDays(1).ToString("yyyy-MM-dd HH:mm") + "'");
sql.Append(")");
}
}
else if (DateTimeResolution == Classes.DateTimeResolution.Month)
{
if (Operator == CompareOperator.LessThan)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + (new DateTime(v.Year, v.Month, 1)).ToString("yyyy-MM-dd HH:mm") + "'");
}
if (Operator == CompareOperator.LessThanOrEqualTo)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + (new DateTime(v.Year, v.Month, 1)).AddMonths(1).ToString("yyyy-MM-dd HH:mm") + "'");
}
if (Operator == CompareOperator.EqualTo)
{
sql.Append("(");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + (new DateTime(v.Year, v.Month, 1)).ToString("yyyy-MM-dd HH:mm") + "'");
sql.Append(" and ");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + (new DateTime(v.Year, v.Month, 1)).AddMonths(1).ToString("yyyy-MM-dd HH:mm") + "'");
sql.Append(")");
}
if (Operator == CompareOperator.GreaterThanOrEqualTo)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + (new DateTime(v.Year, v.Month, 1)).ToString("yyyy-MM-dd HH:mm") + "'");
}
if (Operator == CompareOperator.GreaterThan)
{
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + (new DateTime(v.Year, v.Month, 1)).AddMonths(1).ToString("yyyy-MM-dd HH:mm") + "'");
}
if (Operator == CompareOperator.NotEqualTo)
{
sql.Append("(");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.LessThan));
sql.Append("'" + (new DateTime(v.Year, v.Month, 1)).ToString("yyyy-MM-dd HH:mm") + "'");
sql.Append(" or ");
sql.Append(FieldName);
sql.Append(ToDatabaseOperator(CompareOperator.GreaterThanOrEqualTo));
sql.Append("'" + (new DateTime(v.Year, v.Month, 1)).AddMonths(1).ToString("yyyy-MM-dd HH:mm") + "'");
sql.Append(")");
}
}
else
{
throw new NotImplementedException("'" + DateTimeResolution.ToString() + "' är inte implementerat.");
}
}
}
return(sql.ToString());
}
public Jarvis()
{
dialogos = new DialogSet();
// Dialogo pra previsao do tempo
dialogos.Add("previsaoTempo", new WaterfallStep[] {
async(dc, args, next) =>
{
IDictionary <string, object> estadoDialogo = dc.ActiveDialog.State as IDictionary <string, object>;
object aux = null;
if (args.TryGetValue("Cidade", out aux))
{
estadoDialogo.Add("Cidade", aux.ToString());
dc.ActiveDialog.State = estadoDialogo;
await dc.Continue();
}
else
{
await dc.Prompt("capturaTexto", $"Qual a cidade ?");
}
},
async(dc, args, next) =>
{
IDictionary <string, object> estadoDialogo = dc.ActiveDialog.State as IDictionary <string, object>;
if (!estadoDialogo.ContainsKey("Cidade"))
{
estadoDialogo.Add("Cidade", ((TextResult)args).Value);
}
await dc.Context.SendActivity($"A previsão do tempo no {estadoDialogo["Cidade"]} é de tempo bom.");
await dc.End();
}
});
// Dialogo pra marcar consulta
dialogos.Add("marcarConsulta", new WaterfallStep[] {
async(dc, args, next) =>
{
await dc.Prompt("capturaTexto", "Qual o seu nome ?");
},
async(dc, args, next) =>
{
await dc.Prompt("capturaTexto", $"Qual o convênio ?");
},
async(dc, args, next) =>
{
await dc.Prompt("capturaDataHora", "Certo... Qual o dia e horário ?");
},
async(dc, args, next) =>
{
DateTimeResolution resultado = ((DateTimeResult)args).Resolution.First();
var dataHora = Convert.ToDateTime(resultado.Value);
await dc.Context.SendActivity($"Está marcado. Dia {dataHora.ToString("dd/MM/yyyy HH:mm:ss")}");
await dc.End();
},
});
// Pedir pizza
dialogos.Add("pedirPizza", new WaterfallStep[] {
async(dc, args, next) =>
{
IDictionary <string, object> estadoDialogo = dc.ActiveDialog.State as IDictionary <string, object>;
object aux = null;
if (args.TryGetValue("Sabor", out aux))
{
estadoDialogo.Add("Sabor", aux.ToString());
}
if (args.TryGetValue("Tamanho", out aux))
{
estadoDialogo.Add("Tamanho", aux.ToString());
}
dc.ActiveDialog.State = estadoDialogo;
if (!estadoDialogo.ContainsKey("Sabor"))
{
await dc.Prompt("capturaTexto", $"Qual o sabor da pizza ?");
}
else
{
await dc.Continue();
}
},
async(dc, args, next) =>
{
IDictionary <string, object> estadoDialogo = dc.ActiveDialog.State as IDictionary <string, object>;
if (!estadoDialogo.ContainsKey("Sabor"))
{
estadoDialogo.Add("Sabor", ((TextResult)args).Value);
dc.ActiveDialog.State = estadoDialogo;
}
if (!estadoDialogo.ContainsKey("Tamanho"))
{
await dc.Prompt("capturaTexto", "Qual o tamanho ?");
}
else
{
await dc.Continue();
}
},
async(dc, args, next) =>
{
IDictionary <string, object> estadoDialogo = dc.ActiveDialog.State as IDictionary <string, object>;
if (!estadoDialogo.ContainsKey("Tamanho"))
{
estadoDialogo.Add("Tamanho", ((TextResult)args).Value);
dc.ActiveDialog.State = estadoDialogo;
}
await dc.Prompt("capturaTexto", "Qual o endereço de entrega ?");
},
async(dc, args, next) =>
{
IDictionary <string, object> estadoDialogo = dc.ActiveDialog.State as IDictionary <string, object>;
await dc.Prompt("capturaTexto", $"Ok, sua pizza {estadoDialogo["Tamanho"]} de {estadoDialogo["Sabor"]} será entregue por volta de 40 minutos.");
await dc.End();
}
});
dialogos.Add("capturaDataHora", new Microsoft.Bot.Builder.Dialogs.DateTimePrompt(Culture.Portuguese));
dialogos.Add("capturaTexto", new Microsoft.Bot.Builder.Dialogs.TextPrompt());
}
public static Condition Interval(string fieldName, DateTime fromValue, DateTime toValue, DateTimeResolution resolution)
{
Condition condition = new Condition(fieldName, CompareOperator.GreaterThanOrEqualTo, fromValue, resolution);
condition.AndConditions.Add(new Condition(fieldName, CompareOperator.LessThanOrEqualTo, toValue, resolution));
return(condition);
}
/// <summary>
/// Compare two nullable datetime to a particular resolution
/// </summary>
/// <param name="dateTime"></param>
/// <param name="compareDateTime"></param>
/// <param name="resolution"></param>
/// <returns></returns>
public static bool IsEqualTo(this DateTime? dateTime,
DateTime? compareDateTime,
DateTimeResolution resolution = DateTimeResolution.Millisecond)
{
if (!dateTime.HasValue && !compareDateTime.HasValue)
{
return true;
}
if (dateTime.HasValue && compareDateTime.HasValue)
{
return IsEqualTo(dateTime.Value, compareDateTime.Value, resolution);
}
return false;
}
/// <summary>
/// Truncates a DateTime value to the nearest partial value.
/// </summary>
/// <remarks>
/// From: http://stackoverflow.com/questions/1004698/how-to-truncate-milliseconds-off-of-a-net-datetime
/// </remarks>
/// <param name="date"></param>
/// <param name="resolution"></param>
/// <returns></returns>
public static DateTime Truncate(DateTime date, DateTimeResolution resolution = DateTimeResolution.Second)
{
switch (resolution)
{
case DateTimeResolution.Year:
return new DateTime(date.Year, 1, 1, 0, 0, 0, 0, date.Kind);
case DateTimeResolution.Month:
return new DateTime(date.Year, date.Month, 1, 0, 0, 0, date.Kind);
case DateTimeResolution.Day:
return new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, date.Kind);
case DateTimeResolution.Hour:
return date.AddTicks(-(date.Ticks % TimeSpan.TicksPerHour));
case DateTimeResolution.Minute:
return date.AddTicks(-(date.Ticks % TimeSpan.TicksPerMinute));
case DateTimeResolution.Second:
return date.AddTicks(-(date.Ticks % TimeSpan.TicksPerSecond));
case DateTimeResolution.Millisecond:
return date.AddTicks(-(date.Ticks % TimeSpan.TicksPerMillisecond));
case DateTimeResolution.Tick:
return date.AddTicks(0);
default:
throw new ArgumentException("unrecognized resolution", "resolution");
}
}
/// <summary>
/// Compare two date times
/// </summary>
/// <param name="dateTime"></param>
/// <param name="compareDateTime"></param>
/// <param name="resolution"></param>
/// <returns></returns>
public static bool IsEqualTo(this DateTime? dateTime, DateTime compareDateTime, DateTimeResolution resolution = DateTimeResolution.Millisecond)
{
return dateTime.HasValue && IsEqualTo(dateTime.Value, compareDateTime);
}
