public object Execute(VariableContext context = null)
{
var leftVal = this.Left.Execute(context);
var rightVal = this.Right.Execute(context);
if (leftVal is Variable l && rightVal is Variable r)
{
if (l.ValueType != r.ValueType)
{
throw new FEELException("The variable type does not match for the arithmetic action");
}
switch (l.ValueType)
{
case DataTypeEnum.Decimal:
return(new Variable(l.NumericVal + r.NumericVal));
case DataTypeEnum.String:
return(new Variable($"{l.StringVal}{r.StringVal}"));
case DataTypeEnum.Date:
case DataTypeEnum.DateTime:
case DataTypeEnum.Time:
case DataTypeEnum.YearMonthDuration:
case DataTypeEnum.DayTimeDuration:
return(DateAndTimeHelper.Addition(l, r));
default:
throw new FEELException("Failed to perform addition to incorrect FEEL type");
}
}
throw new FEELException("Failed to perform addition due to values not being a variable");
}
public object Execute(VariableContext context = null)
{
var dateExprVar = DateExpression.Execute();
if (dateExprVar is Variable dateExprOut)
{
switch (DateFunction)
{
case "date":
return(DateAndTimeHelper.DateVal(dateExprOut.StringVal));
case "date and time":
return(DateAndTimeHelper.DateTimeVal(dateExprOut.StringVal));
case "time":
return(DateAndTimeHelper.TimeVal(dateExprOut.StringVal));
case "duration":
return(DateAndTimeHelper.DurationVal(dateExprOut.StringVal));
default:
throw new FEELException($"The following date function {DateFunction} is not supported");
}
}
throw new FEELException($"Failed executing date function {DateFunction}");
}
public void Evaluate_YearAndMonthDurationFunc(string exprText, string expected)
{
Variable variable = ParseAndEval(exprText);
var expectedVal = DateAndTimeHelper.DurationVal(expected);
Assert.Equal(expectedVal, variable);
}
public static Variable MakeVariable(object value, string typeName)
{
if (value == null)
{
return(new Variable());
}
switch (typeName.ToLower())
{
case "string":
return(value.ToString());
case "number":
case "decimal":
case "double":
return(Decimal.Parse(value.ToString()));
case "boolean":
return(bool.Parse(value.ToString()));
case "date":
return(DateAndTimeHelper.DateVal(value.ToString()));
case "dateTime":
case "datetime":
return(DateAndTimeHelper.DateTimeVal(value.ToString()));
case "time":
return(DateAndTimeHelper.TimeVal(value.ToString()));
case "yearmonthduration":
case "daytimeduration":
case "duration":
return(DateAndTimeHelper.DurationVal(value.ToString()));
default:
throw new NotImplementedException($"The following type: {typeName} is not supported for a variable");
}
}
public static Variable MakeVariable(object value, DataTypeEnum typeEnum)
{
if (value == null)
{
return(new Variable());
}
switch (typeEnum)
{
case DataTypeEnum.String:
return(value.ToString());
case DataTypeEnum.Decimal:
return(Decimal.Parse(value.ToString()));
case DataTypeEnum.Boolean:
return(bool.Parse(value.ToString()));
case DataTypeEnum.Date:
return(DateAndTimeHelper.DateVal(value.ToString()));
case DataTypeEnum.DateTime:
return(DateAndTimeHelper.DateTimeVal(value.ToString()));
case DataTypeEnum.Time:
return(DateAndTimeHelper.TimeVal(value.ToString()));
case DataTypeEnum.YearMonthDuration:
case DataTypeEnum.DayTimeDuration:
return(DateAndTimeHelper.DurationVal(value.ToString()));
case DataTypeEnum.Null:
return(new Variable());
default:
throw new NotImplementedException($"The following type: {typeEnum} is not supported for a variable");
}
}
public async Task Load48HoursWeatherInfo()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
await GeolocationHelper.GetGeolocationInfo(geoModel);
var result = await HttpConnection.Get48HoursWeatherInfoAsync(geoModel.Lat, geoModel.Lon, "apiKey");
if (result.Hourly != null)
{
foreach (var item in result.Hourly)
{
Hourly48ForecastList.Add(new Forecast48HoursModel
{
Dt = DateAndTimeHelper.ConvertToDateAndTime(item.Dt, DateAndTimeHelper.TypeForDateAndTimeFormat.TIME),
DateAndTime = DateAndTimeHelper.ConvertToDateAndTime(item.Dt, DateAndTimeHelper.TypeForDateAndTimeFormat.DATE_AND_TIME_FOR_48FORECAST),
Temp = Math.Round(item.Temp.Value, 1).ToString(),
Icon = HttpConnection.GetIconForWeather(item.Weather.First().Icon),
WindDeg = WindHelper.DegreesToGeogrpahicalDirections(item.WindDeg.Value),
GroupName = DateAndTimeHelper.ConvertToDateAndTime(item.Dt, DateAndTimeHelper.TypeForDateAndTimeFormat.COMMON_DATETIME),
ColorOfTemperatureLabel = item.Weather.First().Icon.Contains("n")?"#000000": "#008000",
Humidity = item.Humidity,
WindSpeed = WindHelper.MpsToKmph(item.WindSpeed.Value),
Rain = string.IsNullOrEmpty(item.Rain) ? "0" : item.Rain,
Clouds = item.Clouds,
Pressure = item.Pressure,
Description = item.Weather.First().Description,
FeelsTemp = Math.Round(item.FeelsLike.Value, 1).ToString()
});
}
List <string> groupNamesList = new List <string>();
foreach (var item in Hourly48ForecastList)
{
groupNamesList.Add(item.GroupName);
}
var distinctGroupNamesList = groupNamesList.Distinct().ToList();
foreach (var item in distinctGroupNamesList)
{
GroupedHourly48ForecastList.Add(new GroupingForListClass <string, Forecast48HoursModel>(item, Hourly48ForecastList.Where(x => x.GroupName == item)));
}
}
else
{
await App.Current.MainPage.DisplayAlert("Błąd", "Coś poszło nie tak.", "OK");
}
}
catch (Exception ex)
{
await App.Current.MainPage.DisplayAlert("Błąd", "Coś poszło nie tak.", "OK");
}
finally
{
IsBusy = false;
}
}
public object Execute(VariableContext context = null)
{
if (Names.Count == 1)
{
var funcVar = VariableContextHelper.RetrieveFunctionInput(context, Names[0], false);
if (funcVar != null)
{
return(funcVar);
}
var outVar = VariableContextHelper.RetrieveInputVariable(context, Names[0], false);
if (outVar != null)
{
return(outVar);
}
outVar = VariableContextHelper.RetrieveGlobalVariable(context, Names[0], false);
if (outVar != null)
{
return(outVar);
}
var decisionVar = DMNDoerHelper.EvaluateDecisionByName(context, Names[0]);
if (decisionVar != null)
{
//all the values that override is always string variable
var overrideVar = VariableContextHelper.RetrieveInputVariable(context, Names[0], false);
if (overrideVar != null)
{
return(VariableHelper.MakeVariable(overrideVar.StringVal, decisionVar.ValueType));
}
return(decisionVar);
}
return(new Variable(Names[0]));
}
//Context parent child layers
var ctxVar = VariableContextHelper.RetrieveInputVariable(context, Names[0], false);
if (ctxVar == null)
{
ctxVar = VariableContextHelper.RetrieveGlobalVariable(context, Names[0], false);
}
if (ctxVar == null)
{
ctxVar = DMNDoerHelper.EvaluateDecisionByName(context, Names[0]);
//all the values that override is always string variable
var overrideVar = VariableContextHelper.RetrieveInputVariable(context, Names[0], false);
if (overrideVar != null)
{
var overrideTyped = VariableHelper.MakeVariable(overrideVar.StringVal, ctxVar.ValueType);
ctxVar = overrideTyped;
}
}
if (ctxVar == null && ctxVar.ValueType != DataTypeEnum.Context)
{
throw new FEELException("Failed finding a context variable");
}
for (int i = 1; i < Names.Count; i++)
{
switch (ctxVar.ValueType)
{
case DataTypeEnum.Context:
ctxVar = FindContextVariable(Names[i], ctxVar);
break;
case DataTypeEnum.Date:
return(DateAndTimeHelper.DatePropEvals(ctxVar, Names[i]));
case DataTypeEnum.DateTime:
return(DateAndTimeHelper.DateTimePropEvals(ctxVar, Names[i]));
case DataTypeEnum.Time:
return(DateAndTimeHelper.TimePropEvals(ctxVar, Names[i]));
case DataTypeEnum.YearMonthDuration:
case DataTypeEnum.DayTimeDuration:
return(DateAndTimeHelper.DurationPropEvals(ctxVar, Names[i]));
default:
throw new FEELException($"Path expression for {ctxVar.ValueType} is not supported");
}
}
return(ctxVar);
}
public object Execute(VariableContext context = null)
{
var parentVal = Parent.Execute(context);
if (parentVal is Variable parentVar)
{
switch (parentVar.ValueType)
{
case DataTypeEnum.Context:
parentVar.ContextInputs.ContextDict.TryGetValue(Child, out Variable contextOut);
return(contextOut);
case DataTypeEnum.List:
if (parentVar.ListVal.Count == 1)
{
if (parentVar.ListVal[0].ValueType != DataTypeEnum.Context)
{
throw new FEELException("List of context types is supported for path expressions");
}
var ctx = parentVar.ListVal[0].ContextInputs;
ctx.ContextDict.TryGetValue(Child, out Variable lCtx);
return(lCtx);
}
if (parentVar.ListVal.Count > 1)
{
var outList = new List <Variable> ();
foreach (var item in parentVar.ListVal)
{
if (item.ValueType != DataTypeEnum.Context)
{
throw new FEELException("List of context types is supported for path expressions");
}
var ctx = item.ContextInputs;
ctx.ContextDict.TryGetValue(Child, out Variable lCtx);
outList.Add(lCtx);
}
return(new Variable(outList));
}
throw new FEELException("Empty list for path expression");
case DataTypeEnum.Date:
return(DateAndTimeHelper.DatePropEvals(parentVar, Child));
case DataTypeEnum.DateTime:
return(DateAndTimeHelper.DateTimePropEvals(parentVar, Child));
case DataTypeEnum.Time:
return(DateAndTimeHelper.TimePropEvals(parentVar, Child));
case DataTypeEnum.YearMonthDuration:
case DataTypeEnum.DayTimeDuration:
return(DateAndTimeHelper.DurationPropEvals(parentVar, Child));
default:
throw new FEELException($"Path expression for {parentVar.ValueType} is not supported");
}
}
throw new FEELException("Parent source is not a variable type");
}
public Variable Execute(List <Variable> parameters)
{
return(DateAndTimeHelper.YearMonthDurationFunction(parameters));
}
public Variable Execute(List <Variable> parameters)
{
parameters.ExpectedParamCount(1);
return(DateAndTimeHelper.DurationVal(parameters[0].StringVal));
}
public async Task LoadActualAndDailyWeatherInfoForSevenDays()
{
if (IsBusy)
{
return;
}
DailyForecastList.Clear();
IsBusy = true;
try
{
var result = await HttpConnection.GetActualWeatherInfoForLocationAsync(geoModel.Location, "apiKey");
if (result != null)
{
Location = result.Name;
DescriptionOfWeather = result.Weather.First().Description;
DateAndTime = DateAndTimeHelper.ConvertToDateAndTime(result.Dt, DateAndTimeHelper.TypeForDateAndTimeFormat.COMMON_DATETIME);
SunriseTime = DateAndTimeHelper.ConvertToDateAndTime(result.Sys.Sunrise, DateAndTimeHelper.TypeForDateAndTimeFormat.TIME);
SunsetTime = DateAndTimeHelper.ConvertToDateAndTime(result.Sys.Sunset, DateAndTimeHelper.TypeForDateAndTimeFormat.TIME);
Temperature = Math.Round(result.Main.Temp.Value, 1).ToString();
FeelsLikeTemperature = Math.Round(result.Main.FeelsLike.Value, 1).ToString();
Humidity = result.Main.Humidity;
WindSpeed = WindHelper.MpsToKmph(result.Wind.Speed.Value);
Pressure = result.Main.Pressure;
Clouds = result.Clouds.All;
WindDirection = WindHelper.DegreesToGeogrpahicalDirections(result.Wind.Deg.Value);
Icon = HttpConnection.GetIconForWeather(result.Weather.First().Icon);
}
else
{
await App.Current.MainPage.DisplayAlert("Błąd", "Coś poszło nie tak.", "OK");
}
var resultForDailyWeatherInfo = await HttpConnection.GetDailyWeatherInfoForSevenDaysAsync(geoModel.Lat, geoModel.Lon, "apiKey");
if (resultForDailyWeatherInfo.Daily != null)
{
foreach (var item in resultForDailyWeatherInfo.Daily)
{
DailyForecastList.Add(new DailyForecastForSevenDaysModel
{
Dt = DateAndTimeHelper.ConvertToDateAndTime(item.Dt, DateAndTimeHelper.TypeForDateAndTimeFormat.COMMON_DATETIME),
DayTemp = Math.Round(item.Temp.Day.Value, 1).ToString(),
NightTemp = Math.Round(item.Temp.Night.Value, 1).ToString(),
MinTemp = Math.Round(item.Temp.Min.Value, 1).ToString(),
MaxTemp = Math.Round(item.Temp.Max.Value, 1).ToString(),
FeelsTempDay = Math.Round(item.FeelsLike.Day.Value, 1).ToString(),
Humidity = item.Humidity,
Sunrise = DateAndTimeHelper.ConvertToDateAndTime(item.Sunrise, DateAndTimeHelper.TypeForDateAndTimeFormat.TIME),
Sunset = DateAndTimeHelper.ConvertToDateAndTime(item.Sunset, DateAndTimeHelper.TypeForDateAndTimeFormat.TIME),
WindDeg = WindHelper.DegreesToGeogrpahicalDirections(item.WindDeg.Value),
WindSpeed = WindHelper.MpsToKmph(item.WindSpeed.Value),
Rain = string.IsNullOrEmpty(item.Rain) ? "0" : item.Rain,
Icon = HttpConnection.GetIconForWeather(item.Weather.First().Icon),
Clouds = item.Clouds,
Pressure = item.Pressure,
Description = item.Weather.First().Description
});
}
}
else
{
await App.Current.MainPage.DisplayAlert("Błąd", "Coś poszło nie tak.", "OK");
}
}
catch (Exception ex)
{
await App.Current.MainPage.DisplayAlert("Błąd", "Coś poszło nie tak. Być może nie włączono Internetu.", "OK");
System.Diagnostics.Process.GetCurrentProcess().CloseMainWindow();
}
finally
{
IsBusy = false;
}
}
public Variable Execute(List <Variable> parameters)
{
return(DateAndTimeHelper.DateTimeFunction(parameters));
}
