public ActionResult DeleteWidget()
{
bool ret = true;
try
{
DashboardWidget qw = new DashboardWidget(ConnectionString);
GetDashboardObject DashBoardObject = (GetDashboardObject)Session["DashBoard"];
WidgetObject PostDataArrived = CS.GetPostData <WidgetObject>(this.Request);
ret = qw.DeleteWidget(PostDataArrived.id);
DashboardRow dRow = DashBoardObject.rows.Find(r => r.widgets.Find(w => w.id == PostDataArrived.id) != null);
dRow.widgets.Remove(dRow.widgets.Find(w => w.id == PostDataArrived.id));
Session["DashBoard"] = DashBoardObject;
return(CS.ReturnForJQuery(ret));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(new JavaScriptSerializer().Serialize(new ISTAT.WebClient.Models.ControllerSupport.StringResult()
{
Msg = ex.Message
})));
}
}
public ActionResult DeleteDashboard()
{
try
{
GetDashboardObject DashBoardObject = CS.GetPostData <GetDashboardObject>(this.Request);
DashboardWidget dBWidget = new DashboardWidget(ConnectionString);
//DashBoardObject.id = dBWidget.CreateDashBoard(DashBoardObject);
if (DashBoardObject.id == -1)
{
return(CS.ReturnForJQuery(JSONConst.Error));
}
ConnectionStringSettings connectionStringSetting = ConfigurationManager.ConnectionStrings["ISTATWebClientConnection"];
if (connectionStringSetting == null || string.IsNullOrEmpty(connectionStringSetting.ConnectionString))
{
throw new Exception("ConnectionString not set");
}
DashboardWidget qw = new DashboardWidget(connectionStringSetting.ConnectionString);
return(CS.ReturnForJQuery((qw.Delete(DashBoardObject.id)) ? JSONConst.Success : JSONConst.Error));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(JSONConst.Error));
}
}
public ActionResult DeleteRow()
{
DashboardRow DBRow = CS.GetPostData <DashboardRow>(this.Request);
try
{
DashboardWidget qw = new DashboardWidget(ConnectionString);
GetDashboardObject DashBoardObject = (GetDashboardObject)Session["DashBoard"];
qw.DeleteRow(DBRow.id);
DashBoardObject.rows.Remove(DashBoardObject.rows.Find(c => c.id == DBRow.id));
Session["DashBoard"] = DashBoardObject;
return(CS.ReturnForJQuery(DBRow));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(new JavaScriptSerializer().Serialize(new ISTAT.WebClient.Models.ControllerSupport.StringResult()
{
Msg = ex.Message
})));
}
}
public ActionResult AddWidget()
{
WidgetObject woRet;
try
{
DashboardWidget qw = new DashboardWidget(ConnectionString);
GetDashboardObject DashBoardObject = (GetDashboardObject)Session["DashBoard"];
WidgetObject PostDataArrived = CS.GetPostData <WidgetObject>(this.Request);
woRet = qw.AddWidget(PostDataArrived);
DashboardRow dbRow = DashBoardObject.rows.Find(r => r.id == woRet.rowID);
if (dbRow.widgets == null)
{
dbRow.widgets = new List <WidgetObject>();
}
dbRow.widgets.Add(woRet);
Session["DashBoard"] = DashBoardObject;
return(CS.ReturnForJQuery(woRet));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(new JavaScriptSerializer().Serialize(new ISTAT.WebClient.Models.ControllerSupport.StringResult()
{
Msg = ex.Message
})));
}
}
public ActionResult UpdateRow()
{
try
{
DashboardWidget qw = new DashboardWidget(ConnectionString);
DashboardRow UpdatedDashBoardRow;
DashboardRow PostDataArrived = CS.GetPostData <DashboardRow>(this.Request);
GetDashboardObject DashBoardObject = (GetDashboardObject)Session["DashBoard"];
UpdatedDashBoardRow = qw.UpdateRow(PostDataArrived);
var row_widget = DashBoardObject.rows.Find(c => c.id == PostDataArrived.id);
UpdatedDashBoardRow.widgets = row_widget.widgets;
DashBoardObject.rows.Remove(row_widget);
DashBoardObject.rows.Add(UpdatedDashBoardRow);
Session["DashBoard"] = DashBoardObject;
return(CS.ReturnForJQuery(UpdatedDashBoardRow));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(new JavaScriptSerializer().Serialize(new ISTAT.WebClient.Models.ControllerSupport.StringResult()
{
Msg = ex.Message
})));
}
}
public ActionResult AddRow()
{
DashboardRow DBRow;
try
{
DashboardWidget qw = new DashboardWidget(ConnectionString);
GetDashboardObject DashBoardObject = (GetDashboardObject)Session["DashBoard"];
DBRow = qw.AddRow(DashBoardObject.id, false, -1);
if (DashBoardObject.rows == null)
{
DashBoardObject.rows = new List <DashboardRow>();
}
DashBoardObject.rows.Add(DBRow);
Session["DashBoard"] = DashBoardObject;
return(CS.ReturnForJQuery(DBRow));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(new JavaScriptSerializer().Serialize(new ISTAT.WebClient.Models.ControllerSupport.StringResult()
{
Msg = ex.Message
})));
}
}
private void SetCachePolicy(DashboardWidget widget)
{
// flush the cache whenever a change is made
widget.CachedContent = null;
widget.CacheExpires = null;
CurrentDatabase.SubmitChanges();
}
public bool DeleteDashboardWidget(DashboardWidget dashboardWidget)
{
if (dashboardWidget == null) return false;
_unitOfWork.DashboardWidgetRepository.Delete(dashboardWidget);
_unitOfWork.Save();
return true;
}
public ActionResult CreateDashboard()
{
try
{
GetDashboardObject DashBoardObject = CS.GetPostData <GetDashboardObject>(this.Request);
DashboardWidget dBWidget = new DashboardWidget(ConnectionString);
DashBoardObject.id = dBWidget.CreateDashBoard(DashBoardObject);
if (DashBoardObject.id == -1)
{
return(CS.ReturnForJQuery(JSONConst.Error));
}
Session["DashBoard"] = DashBoardObject;
AddRow();
return(CS.ReturnForJQuery(DashBoardObject));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(JSONConst.Error));
}
}
public IActionResult Index()
{
// Setting Store Info Here
ViewBag.StoreID = ActiveSession.GetActiveSession(HttpContext.Session, HttpContext.Response, "/Identity/Account/Login?ReturnUrl=/Home/Index");
MasterViewReport mvr = DashboardWidget.GetMasterViewReport(_context);
return(View(mvr));
}
public bool DeleteDashboardWidget(DashboardWidget dashboardWidget)
{
if (dashboardWidget == null)
{
return(false);
}
_unitOfWork.DashboardWidgetRepository.Delete(dashboardWidget);
_unitOfWork.Save();
return(true);
}
public PartialViewResult SearchStory(int roomId, string searchText)
{
DashboardWidget stories = new DashboardWidget
{
StoryDetailsList = new Rooms(iHttpContextAccessor, isignalRhub).GetStoryList(roomId, searchText)
};
return(stories.StoryDetailsList != null && stories.StoryDetailsList.Count > 0
? this.PartialView("~/Views/Home/_Stories.cshtml", stories)
: this.PartialView("~/Views/Home/_NoStory.cshtml"));
}
private void UpdateContent(DashboardWidget widget)
{
var widgetContentIds = new[] { HTMLContentId, PythonContentId, SQLContentId };
var contents = CurrentDatabase.Contents.Where(c => widgetContentIds.Contains(c.Id));
widget.CopyPropertiesFrom(this, excludefields: "HTMLContentId,PythonContentId,SQLContentId");
widget.HTMLContent = contents.Where(c => c.Id == HTMLContentId).SingleOrDefault();
widget.HTMLContentId = (HTMLContentId == 0) ? (int?)null : HTMLContentId;
widget.PythonContent = contents.Where(c => c.Id == PythonContentId).SingleOrDefault();
widget.PythonContentId = (PythonContentId == 0) ? (int?)null : PythonContentId;
widget.SQLContent = contents.Where(c => c.Id == SQLContentId).SingleOrDefault();
widget.SQLContentId = (SQLContentId == 0) ? (int?)null : SQLContentId;
}
public ActionResult GetDashboardsActive()
{
try
{
DashboardWidget qw = new DashboardWidget(ConnectionString);
GetDashboardObject PostDataArrived = CS.GetPostData <GetDashboardObject>(this.Request);
return(CS.ReturnForJQuery(qw.Load(-1, true)));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(JSONConst.Error));
}
}
public DashboardWidgetModel(string id, CMSDataContext db)
{
CurrentDatabase = db;
DashboardWidget widget;
if (id.ToLower() == "new")
{
Id = 0;
widget = new DashboardWidget();
}
else
{
Id = id.ToInt();
widget = CurrentDatabase.DashboardWidgets.Where(w => w.Id == id.ToInt()).Single();
}
this.Fill(widget);
}
void setContext(ITypeDescriptorContext context)
{
_metaConnection = context.Instance as MetaConnection;
_metaEnum = context.Instance as MetaEnum;
_metaTable = context.Instance as MetaTable;
_metaColumn = context.Instance as MetaColumn;
_metaJoin = context.Instance as MetaJoin;
_reportView = context.Instance as ReportView;
_reportOutput = context.Instance as ReportOutput;
_reportSchedule = context.Instance as ReportSchedule;
_parameter = context.Instance as Parameter;
_security = context.Instance as SealSecurity;
_emailDevice = context.Instance as OutputEmailDevice;
_fileServerDevice = context.Instance as OutputFileServerDevice;
_model = context.Instance as ReportModel;
_configuration = context.Instance as SealServerConfiguration;
_widget = context.Instance as DashboardWidget;
}
private void Fill(DashboardWidget widget)
{
Name = widget.Name;
Description = widget.Description;
HTMLContentId = widget.HTMLContentId ?? 0;
PythonContentId = widget.PythonContentId ?? 0;
SQLContentId = widget.SQLContentId ?? 0;
Enabled = widget.Enabled;
Order = widget.Order;
System = widget.System;
HTMLContent = widget.HTMLContent;
PythonContent = widget.PythonContent;
SQLContent = widget.SQLContent;
CachePolicy = widget.CachePolicy == CachePolicies.NeverCache.ToInt() ? CachePolicies.PerUser.ToInt() : widget.CachePolicy;
CacheHours = widget.CacheHours;
CacheExpires = widget.CacheExpires;
CachedContent = widget.CachedContent;
Roles = widget.DashboardWidgetRoles.Select(r => r.RoleId).ToArray();
}
public ActionResult ActiveDashboard()
{
try
{
GetDashboardObject PostDataArrived = CS.GetPostData <GetDashboardObject>(this.Request);
ConnectionStringSettings connectionStringSetting = ConfigurationManager.ConnectionStrings["ISTATWebClientConnection"];
if (connectionStringSetting == null || string.IsNullOrEmpty(connectionStringSetting.ConnectionString))
{
throw new Exception("ConnectionString not set");
}
DashboardWidget qw = new DashboardWidget(connectionStringSetting.ConnectionString);
return(CS.ReturnForJQuery(qw.Active(PostDataArrived.id, PostDataArrived.active)));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(JSONConst.Error));
}
}
public static SmDashboardWidget Build(DashboardWidget entity)
{
if (entity == null)
{
return(null);
}
return(new SmDashboardWidget
{
DashboardId = entity.DashboardId,
WidgetId = entity.WidgetInstance.WidgetId,
WidgetType = (Common.Enums.WidgetType)entity.WidgetInstance.Widget.WidgetTypeId,
WidgetInstanceId = entity.WidgetInstanceId,
Title = entity.WidgetInstance.Title,
Order = entity.WidgetInstance.LayoutOrdinalId,
Json = entity.WidgetInstance.Json,
JsonVersion = entity.WidgetInstance.JsonVersion,
IsVisible = entity.WidgetInstance.IsVisible
});
}
public ActionResult GetDashboards()
{
try
{
DashboardWidget qw = new DashboardWidget(ConnectionString);
if (ConnectionString.ToLower() != "file")
{
return(CS.ReturnForJQuery(qw.Load()));
}
else
{
return(null);
}
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(new JavaScriptSerializer().Serialize(new ISTAT.WebClient.Models.ControllerSupport.StringResult()
{
Msg = ex.Message
})));
}
}
public ActionResult PreviewDashboard()
{
try
{
GetDashboardObject PostDataArrived = CS.GetPostData <GetDashboardObject>(this.Request);
List <GetDashboardObject> DashBoardObject;
DashboardWidget qw = new DashboardWidget(ConnectionString);
DashBoardObject = qw.Load(PostDataArrived.id);
Session["DashBoard"] = DashBoardObject[0];
return(CS.ReturnForJQuery(DashBoardObject));
}
catch (Exception ex)
{
return(CS.ReturnForJQuery(new JavaScriptSerializer().Serialize(new ISTAT.WebClient.Models.ControllerSupport.StringResult()
{
Msg = ex.Message
})));
}
}
public void UpdateModel()
{
DashboardWidget widget;
if (Id != 0)
{
// update existing widget
widget = CurrentDatabase.DashboardWidgets.Where(w => w.Id == Id).Single();
UpdateContent(widget);
}
else
{
// create new widget
widget = new DashboardWidget();
UpdateContent(widget);
widget.Order = CurrentDatabase.DashboardWidgets.Max(w => w.Order) + 1;
CurrentDatabase.DashboardWidgets.InsertOnSubmit(widget);
CurrentDatabase.SubmitChanges();
Id = widget.Id;
}
SetRoles(Roles);
SetCachePolicy(widget);
}
public override bool Execute(ProgramOptions programOptions, JobConfiguration jobConfiguration)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
StepTiming stepTimingFunction = new StepTiming();
stepTimingFunction.JobFileName = programOptions.OutputJobFilePath;
stepTimingFunction.StepName = jobConfiguration.Status.ToString();
stepTimingFunction.StepID = (int)jobConfiguration.Status;
stepTimingFunction.StartTime = DateTime.Now;
stepTimingFunction.NumEntities = jobConfiguration.Target.Count;
this.DisplayJobStepStartingStatus(jobConfiguration);
FilePathMap = new FilePathMap(programOptions, jobConfiguration);
try
{
if (this.ShouldExecute(jobConfiguration) == false)
{
return(true);
}
bool reportFolderCleaned = false;
// Process each Controller once
int i = 0;
var controllers = jobConfiguration.Target.GroupBy(t => t.Controller);
foreach (var controllerGroup in controllers)
{
Stopwatch stopWatchTarget = new Stopwatch();
stopWatchTarget.Start();
JobTarget jobTarget = controllerGroup.ToList()[0];
StepTiming stepTimingTarget = new StepTiming();
stepTimingTarget.Controller = jobTarget.Controller;
stepTimingTarget.ApplicationName = jobTarget.Application;
stepTimingTarget.ApplicationID = jobTarget.ApplicationID;
stepTimingTarget.JobFileName = programOptions.OutputJobFilePath;
stepTimingTarget.StepName = jobConfiguration.Status.ToString();
stepTimingTarget.StepID = (int)jobConfiguration.Status;
stepTimingTarget.StartTime = DateTime.Now;
stepTimingTarget.NumEntities = 0;
try
{
this.DisplayJobTargetStartingStatus(jobConfiguration, jobTarget, i + 1);
#region Dashboards List and Widgets List
loggerConsole.Info("Dashboards and their widgets");
List <Dashboard> dashboardsList = new List <Dashboard>(1024);
List <DashboardWidget> dashboardWidgetsAllList = new List <DashboardWidget>(10240);
List <DashboardMetricSeries> dashboardMetricSeriesAllList = new List <DashboardMetricSeries>(10240);
JArray dashboardsArray = FileIOHelper.LoadJArrayFromFile(FilePathMap.ControllerDashboards(jobTarget));
if (dashboardsArray != null)
{
int j = 0;
foreach (JObject dashboardObject in dashboardsArray)
{
Dashboard dashboard = new Dashboard();
dashboard.Controller = jobTarget.Controller;
dashboard.DashboardName = getStringValueFromJToken(dashboardObject, "name");
dashboard.Description = getStringValueFromJToken(dashboardObject, "description");
dashboard.CanvasType = getStringValueFromJToken(dashboardObject, "canvasType").Replace("CANVAS_TYPE_", "");
dashboard.TemplateEntityType = getStringValueFromJToken(dashboardObject, "templateEntityType");
dashboard.SecurityToken = getStringValueFromJToken(dashboardObject, "securityToken");
if (dashboard.SecurityToken.Length > 0)
{
dashboard.IsShared = true;
}
dashboard.IsSharingRevoked = getBoolValueFromJToken(dashboardObject, "sharingRevoked");
dashboard.IsTemplate = getBoolValueFromJToken(dashboardObject, "template");
dashboard.Height = getIntValueFromJToken(dashboardObject, "height");
dashboard.Width = getIntValueFromJToken(dashboardObject, "width");
dashboard.BackgroundColor = getIntValueFromJToken(dashboardObject, "backgroundColor").ToString("X6");
dashboard.MinutesBefore = getIntValueFromJToken(dashboardObject, "minutesBeforeAnchorTime");
dashboard.RefreshInterval = getIntValueFromJToken(dashboardObject, "refreshInterval") / 1000;
dashboard.StartTimeUtc = UnixTimeHelper.ConvertFromUnixTimestamp(getLongValueFromJToken(dashboardObject, "startTime"));
try { dashboard.StartTime = dashboard.StartTimeUtc.ToLocalTime(); } catch { }
dashboard.EndTimeUtc = UnixTimeHelper.ConvertFromUnixTimestamp(getLongValueFromJToken(dashboardObject, "endTime"));
try { dashboard.EndTime = dashboard.EndTimeUtc.ToLocalTime(); } catch { }
dashboard.CreatedBy = getStringValueFromJToken(dashboardObject, "createdBy");
dashboard.CreatedOnUtc = UnixTimeHelper.ConvertFromUnixTimestamp(getLongValueFromJToken(dashboardObject, "createdOn"));
try { dashboard.CreatedOn = dashboard.CreatedOnUtc.ToLocalTime(); } catch { }
dashboard.UpdatedBy = getStringValueFromJToken(dashboardObject, "modifiedBy");
dashboard.UpdatedOnUtc = UnixTimeHelper.ConvertFromUnixTimestamp(getLongValueFromJToken(dashboardObject, "modifiedOn"));
try { dashboard.UpdatedOn = dashboard.UpdatedOnUtc.ToLocalTime(); } catch { }
dashboard.DashboardID = getLongValueFromJToken(dashboardObject, "id");
dashboard.DashboardLink = String.Format(DEEPLINK_DASHBOARD, dashboard.Controller, dashboard.DashboardID, DEEPLINK_TIMERANGE_LAST_15_MINUTES);
// Now parse the Widgets
JObject dashboardDetailObject = FileIOHelper.LoadJObjectFromFile(FilePathMap.ControllerDashboard(jobTarget, dashboard.DashboardName, dashboard.DashboardID));
if (dashboardDetailObject != null && isTokenPropertyNull(dashboardDetailObject, "widgetTemplates") == false)
{
List <DashboardWidget> dashboardWidgetsList = new List <DashboardWidget>(dashboardDetailObject["widgetTemplates"].Count());
int dashboardWidgetIndex = 0;
foreach (JObject dashboardWidgetObject in dashboardDetailObject["widgetTemplates"])
{
DashboardWidget dashboardWidget = new DashboardWidget();
dashboardWidget.Controller = dashboard.Controller;
dashboardWidget.DashboardName = dashboard.DashboardName;
dashboardWidget.DashboardID = dashboard.DashboardID;
dashboardWidget.CanvasType = dashboard.CanvasType;
dashboardWidget.WidgetType = getStringValueFromJToken(dashboardWidgetObject, "widgetType");
dashboardWidget.Index = dashboardWidgetIndex;
dashboardWidget.ApplicationName = getStringValueFromJToken(dashboardWidgetObject["applicationReference"], "applicationName");
dashboardWidget.EntityType = getStringValueFromJToken(dashboardWidgetObject, "entityType");
dashboardWidget.EntitySelectionType = getStringValueFromJToken(dashboardWidgetObject, "entitySelectionType");
try
{
if (isTokenPropertyNull(dashboardWidgetObject, "entityReferences") == false)
{
string[] entities = new string[dashboardWidgetObject["entityReferences"].Count()];
int entitiesIndex = 0;
foreach (JToken entityReferenceToken in dashboardWidgetObject["entityReferences"])
{
string scopingEntityName = getStringValueFromJToken(entityReferenceToken, "scopingEntityName");
string entityName = getStringValueFromJToken(entityReferenceToken, "entityName");
string subType = getStringValueFromJToken(entityReferenceToken, "subtype");
StringBuilder sb = new StringBuilder(100);
sb.Append(scopingEntityName);
if (scopingEntityName.Length > 0)
{
sb.Append("/");
}
sb.Append(entityName);
if (subType.Length > 0)
{
sb.AppendFormat(" [{0}]", subType);
}
entities[entitiesIndex] = sb.ToString();
entitiesIndex++;;
}
dashboardWidget.SelectedEntities = String.Join(";", entities);
dashboardWidget.NumSelectedEntities = entities.Length;
}
}
catch { }
dashboardWidget.Title = getStringValueFromJToken(dashboardWidgetObject, "title");
dashboardWidget.Description = getStringValueFromJToken(dashboardWidgetObject, "description");
dashboardWidget.Label = getStringValueFromJToken(dashboardWidgetObject, "label");
dashboardWidget.Text = getStringValueFromJToken(dashboardWidgetObject, "text");
dashboardWidget.TextAlign = getStringValueFromJToken(dashboardWidgetObject, "textAlign");
dashboardWidget.Width = getIntValueFromJToken(dashboardWidgetObject, "width");
dashboardWidget.Height = getIntValueFromJToken(dashboardWidgetObject, "height");
dashboardWidget.MinWidth = getIntValueFromJToken(dashboardWidgetObject, "minHeight");
dashboardWidget.MinHeight = getIntValueFromJToken(dashboardWidgetObject, "minWidth");
dashboardWidget.X = getIntValueFromJToken(dashboardWidgetObject, "x");
dashboardWidget.Y = getIntValueFromJToken(dashboardWidgetObject, "y");
dashboardWidget.ForegroundColor = getIntValueFromJToken(dashboardWidgetObject, "color").ToString("X6");
dashboardWidget.BackgroundColor = getIntValueFromJToken(dashboardWidgetObject, "backgroundColor").ToString("X6");
dashboardWidget.BackgroundAlpha = getDoubleValueFromJToken(dashboardWidgetObject, "backgroundAlpha");
dashboardWidget.BorderColor = getIntValueFromJToken(dashboardWidgetObject, "borderColor").ToString("X6");
dashboardWidget.BorderSize = getIntValueFromJToken(dashboardWidgetObject, "borderThickness");
dashboardWidget.IsBorderEnabled = getBoolValueFromJToken(dashboardWidgetObject, "borderEnabled");
dashboardWidget.Margin = getIntValueFromJToken(dashboardWidgetObject, "margin");
try { dashboardWidget.NumDataSeries = dashboardWidgetObject["dataSeriesTemplates"].Count(); } catch { }
dashboardWidget.FontSize = getIntValueFromJToken(dashboardWidgetObject, "fontSize");
dashboardWidget.MinutesBeforeAnchor = getIntValueFromJToken(dashboardWidgetObject, "minutesBeforeAnchorTime");
dashboardWidget.VerticalAxisLabel = getStringValueFromJToken(dashboardWidgetObject, "verticalAxisLabel");
dashboardWidget.HorizontalAxisLabel = getStringValueFromJToken(dashboardWidgetObject, "horizontalAxisLabel");
dashboardWidget.AxisType = getStringValueFromJToken(dashboardWidgetObject, "axisType");
dashboardWidget.IsMultipleYAxis = getBoolValueFromJToken(dashboardWidgetObject, "multipleYAxis");
dashboardWidget.StackMode = getStringValueFromJToken(dashboardWidgetObject, "stackMode");
dashboardWidget.AggregationType = getStringValueFromJToken(dashboardWidgetObject, "aggregationType");
dashboardWidget.DrillDownURL = getStringValueFromJToken(dashboardWidgetObject, "drillDownUrl");
dashboardWidget.IsDrillDownMetricBrowser = getBoolValueFromJToken(dashboardWidgetObject, "useMetricBrowserAsDrillDown");
dashboardWidget.IsShowEvents = getBoolValueFromJToken(dashboardWidgetObject, "showEvents");
dashboardWidget.EventFilter = getStringValueOfObjectFromJToken(dashboardWidgetObject, "eventFilterTemplate", false);
dashboardWidget.ImageURL = getStringValueFromJToken(dashboardWidgetObject, "imageURL");
if (dashboardWidget.ImageURL.Length > 0)
{
if (dashboardWidget.ImageURL.StartsWith("data:") == true)
{
dashboardWidget.EmbeddedImageSize = dashboardWidget.ImageURL.Length;
dashboardWidget.ImageURL = "Embedded base64 image";
}
}
dashboardWidget.SourceURL = getStringValueFromJToken(dashboardWidgetObject, "sourceURL");
dashboardWidget.IsSandbox = getBoolValueFromJToken(dashboardWidgetObject, "sandbox");
if (dashboardWidget.WidgetType == "AnalyticsWidget")
{
try
{
if (dashboardWidgetObject["adqlQueryList"].Count() == 0)
{
dashboardWidget.AnalyticsQueries = String.Empty;
}
else if (dashboardWidgetObject["adqlQueryList"].Count() == 1)
{
dashboardWidget.AnalyticsQueries = dashboardWidgetObject["adqlQueryList"][0].ToString();
}
else
{
dashboardWidget.AnalyticsQueries = getStringValueOfObjectFromJToken(dashboardWidgetObject, "adqlQueryList", false);
}
}
catch { }
dashboardWidget.AnalyticsWidgetType = getStringValueFromJToken(dashboardWidgetObject, "analyticsWidgetType");
dashboardWidget.AnalyticsSearchMode = getStringValueFromJToken(dashboardWidgetObject, "searchMode");
}
#region Maybe discern between Widget Types?
//switch (dashboardWidget.WidgetType)
//{
// case "HealthListWidget":
// break;
// case "ImageWidget":
// break;
// case "TextWidget":
// break;
// case "GraphWidget":
// break;
// case "MetricLabelWidget":
// break;
// case "EventListWidget":
// break;
// case "AnalyticsWidget":
// break;
// case "PieWidget":
// break;
// case "GaugeWidget":
// break;
// case "IFrameWidget":
// break;
// default:
// logger.Warn("Unknown Widget Type {0} in {1}, Widget {2}", dashboardWidget.WidgetType, dashboard, dashboardWidget.Index);
// loggerConsole.Warn("Unknown Widget Type {0} in {1}, Widget {2}", dashboardWidget.WidgetType, dashboard, dashboardWidget.Index);
// break;
//}
#endregion
dashboardWidgetsList.Add(dashboardWidget);
// Now process metric data series for widgets that support them
if (dashboardWidget.NumDataSeries > 0)
{
List <DashboardMetricSeries> dashboardMetricSeriesList = new List <DashboardMetricSeries>(dashboardWidget.NumDataSeries);
foreach (JObject dashboardMetricSeriesObject in dashboardWidgetObject["dataSeriesTemplates"])
{
DashboardMetricSeries dashboardMetricSeries = new DashboardMetricSeries();
dashboardMetricSeries.Controller = dashboard.Controller;
dashboardMetricSeries.DashboardName = dashboard.DashboardName;
dashboardMetricSeries.DashboardID = dashboard.DashboardID;
dashboardMetricSeries.CanvasType = dashboard.CanvasType;
dashboardMetricSeries.WidgetType = dashboardWidget.WidgetType;
dashboardMetricSeries.Index = dashboardWidget.Index;
dashboardMetricSeries.SeriesName = getStringValueFromJToken(dashboardMetricSeriesObject, "name");
dashboardMetricSeries.SeriesType = getStringValueFromJToken(dashboardMetricSeriesObject, "seriesType");
dashboardMetricSeries.MetricType = getStringValueFromJToken(dashboardMetricSeriesObject, "metricType");
if (isTokenPropertyNull(dashboardMetricSeriesObject, "colorPalette") == false)
{
if (isTokenPropertyNull(dashboardMetricSeriesObject["colorPalette"], "colors") == false)
{
string[] entities = new string[dashboardMetricSeriesObject["colorPalette"]["colors"].Count()];
int entitiesIndex = 0;
foreach (JToken entityReferenceToken in dashboardMetricSeriesObject["colorPalette"]["colors"])
{
int color = (int)entityReferenceToken;
entities[entitiesIndex] = color.ToString("X6");
entitiesIndex++;;
}
dashboardMetricSeries.Colors = String.Join(";", entities);
dashboardMetricSeries.NumColors = entities.Length;
}
}
dashboardMetricSeries.Axis = getStringValueFromJToken(dashboardMetricSeriesObject, "axisPosition");
if (isTokenPropertyNull(dashboardMetricSeriesObject, "metricMatchCriteriaTemplate") == false)
{
JObject dashboardMetricSeriesMetricMatchCriteriaTemplateObject = (JObject)dashboardMetricSeriesObject["metricMatchCriteriaTemplate"];
dashboardMetricSeries.MaxResults = getIntValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "maxResults");
dashboardMetricSeries.ApplicationName = getStringValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "applicationName");
dashboardMetricSeries.Expression = getStringValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "expressionString");
dashboardMetricSeries.EvalScopeType = getStringValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "evaluationScopeType");
dashboardMetricSeries.Baseline = getStringValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "baselineName");
dashboardMetricSeries.DisplayStyle = getStringValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "metricDisplayNameStyle");
dashboardMetricSeries.DisplayFormat = getStringValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "metricDisplayNameCustomFormat");
dashboardMetricSeries.IsRollup = getBoolValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "rollupMetricData");
dashboardMetricSeries.UseActiveBaseline = getBoolValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "useActiveBaseline");
if (getBoolValueFromJToken(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "sortResultsAscending") == true)
{
dashboardMetricSeries.SortDirection = "Ascending";
}
else
{
dashboardMetricSeries.SortDirection = "Descending";
}
if (isTokenPropertyNull(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "entityMatchCriteria") == false)
{
JObject dashboardMetricSeriesEntityMatchCriteriaObject = (JObject)dashboardMetricSeriesMetricMatchCriteriaTemplateObject["entityMatchCriteria"];
dashboardMetricSeries.IsSummary = getBoolValueFromJToken(dashboardMetricSeriesEntityMatchCriteriaObject, "summary");
dashboardMetricSeries.EntityType = getStringValueFromJToken(dashboardMetricSeriesEntityMatchCriteriaObject, "entityType");
dashboardMetricSeries.EntitySelectionType = getStringValueFromJToken(dashboardMetricSeriesEntityMatchCriteriaObject, "matchCriteriaType");
dashboardMetricSeries.AgentType = getStringValueOfObjectFromJToken(dashboardMetricSeriesEntityMatchCriteriaObject, "agentTypes", true);
if (isTokenPropertyNull(dashboardMetricSeriesEntityMatchCriteriaObject, "entityNames") == false)
{
string[] entities = new string[dashboardMetricSeriesEntityMatchCriteriaObject["entityNames"].Count()];
int entitiesIndex = 0;
foreach (JToken entityReferenceToken in dashboardMetricSeriesEntityMatchCriteriaObject["entityNames"])
{
string scopingEntityName = getStringValueFromJToken(entityReferenceToken, "scopingEntityName");
string entityName = getStringValueFromJToken(entityReferenceToken, "entityName");
string subType = getStringValueFromJToken(entityReferenceToken, "subtype");
StringBuilder sb = new StringBuilder(100);
sb.Append(scopingEntityName);
if (scopingEntityName.Length > 0)
{
sb.Append("/");
}
sb.Append(entityName);
if (subType.Length > 0)
{
sb.AppendFormat(" [{0}]", subType);
}
entities[entitiesIndex] = sb.ToString();
entitiesIndex++;;
}
dashboardMetricSeries.SelectedEntities = String.Join(";", entities);
dashboardMetricSeries.NumSelectedEntities = entities.Length;
}
}
if (isTokenPropertyNull(dashboardMetricSeriesMetricMatchCriteriaTemplateObject, "metricExpressionTemplate") == false)
{
JObject dashboardMetricSeriesMetricExpressionTemplateObject = (JObject)dashboardMetricSeriesMetricMatchCriteriaTemplateObject["metricExpressionTemplate"];
dashboardMetricSeries.MetricExpressionType = getStringValueFromJToken(dashboardMetricSeriesMetricExpressionTemplateObject, "metricExpressionType");
dashboardMetricSeries.MetricDisplayName = getStringValueFromJToken(dashboardMetricSeriesMetricExpressionTemplateObject, "displayName");
if (dashboardMetricSeries.MetricDisplayName == "null")
{
// yes, sometimes that value is saved as string "null"
dashboardMetricSeries.MetricDisplayName = String.Empty;
}
dashboardMetricSeries.FunctionType = getStringValueFromJToken(dashboardMetricSeriesMetricExpressionTemplateObject, "functionType");
dashboardMetricSeries.MetricPath = getStringValueFromJToken(dashboardMetricSeriesMetricExpressionTemplateObject, "relativeMetricPath");
if (dashboardMetricSeries.MetricPath.Length == 0)
{
// Must be dashboardMetricSeries.MetricExpressionType = Absolute
dashboardMetricSeries.MetricPath = getStringValueFromJToken(dashboardMetricSeriesMetricExpressionTemplateObject, "metricPath");
}
if (dashboardMetricSeries.NumSelectedEntities == 0)
{
// Must be dashboardMetricSeries.MetricExpressionType = Absolute
if (isTokenPropertyNull(dashboardMetricSeriesMetricExpressionTemplateObject, "scopeEntity") == false)
{
JObject dashboardMetricSeriesScopeEntityObject = (JObject)dashboardMetricSeriesMetricExpressionTemplateObject["scopeEntity"];
string scopingEntityName = getStringValueFromJToken(dashboardMetricSeriesScopeEntityObject, "scopingEntityName");
string entityName = getStringValueFromJToken(dashboardMetricSeriesScopeEntityObject, "entityName");
string subType = getStringValueFromJToken(dashboardMetricSeriesScopeEntityObject, "subtype");
StringBuilder sb = new StringBuilder(100);
sb.Append(scopingEntityName);
if (scopingEntityName.Length > 0)
{
sb.Append("/");
}
sb.Append(entityName);
if (subType.Length > 0)
{
sb.AppendFormat(" [{0}]", subType);
}
dashboardMetricSeries.SelectedEntities = sb.ToString();
dashboardMetricSeries.NumSelectedEntities = 1;
}
}
if (dashboardMetricSeries.MetricExpressionType == "Boolean")
{
dashboardMetricSeries.ExpressionOperator = getStringValueFromJToken(dashboardMetricSeriesMetricExpressionTemplateObject["operator"], "type");
dashboardMetricSeries.Expression1 = getStringValueOfObjectFromJToken(dashboardMetricSeriesMetricExpressionTemplateObject, "expression1", false);
dashboardMetricSeries.Expression2 = getStringValueOfObjectFromJToken(dashboardMetricSeriesMetricExpressionTemplateObject, "expression2", false);
}
}
}
dashboardMetricSeriesList.Add(dashboardMetricSeries);
}
dashboardMetricSeriesAllList.AddRange(dashboardMetricSeriesList);
}
dashboardWidgetIndex++;
}
dashboardWidgetsAllList.AddRange(dashboardWidgetsList);
dashboard.NumWidgets = dashboardWidgetsList.Count;
dashboard.NumAnalyticsWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "AnalyticsWidget");
dashboard.NumEventListWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "EventListWidget");
dashboard.NumGaugeWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "GaugeWidget");
dashboard.NumGraphWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "GraphWidget");
dashboard.NumHealthListWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "HealthListWidget");
dashboard.NumIFrameWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "IFrameWidget");
dashboard.NumImageWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "ImageWidget");
dashboard.NumMetricLabelWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "MetricLabelWidget");
dashboard.NumPieWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "PieWidget");
dashboard.NumTextWidgets = dashboardWidgetsList.Count(d => d.WidgetType == "TextWidget");
}
dashboardsList.Add(dashboard);
j++;
if (j % 100 == 0)
{
Console.Write("[{0}].", j);
}
}
}
loggerConsole.Info("{0} Dashboards", dashboardsList.Count);
loggerConsole.Info("{0} Dashboard Widgets", dashboardWidgetsAllList.Count);
loggerConsole.Info("{0} Dashboard Widget Time Series", dashboardMetricSeriesAllList.Count);
dashboardsList = dashboardsList.OrderBy(d => d.DashboardName).ToList();
FileIOHelper.WriteListToCSVFile(dashboardsList, new DashboardReportMap(), FilePathMap.DashboardsIndexFilePath(jobTarget));
dashboardWidgetsAllList = dashboardWidgetsAllList.OrderBy(d => d.DashboardName).ThenBy(d => d.Index).ToList();
FileIOHelper.WriteListToCSVFile(dashboardWidgetsAllList, new DashboardWidgetReportMap(), FilePathMap.DashboardWidgetsIndexFilePath(jobTarget));
dashboardMetricSeriesAllList = dashboardMetricSeriesAllList.OrderBy(d => d.DashboardName).ThenBy(d => d.Index).ThenBy(d => d.SeriesName).ToList();
FileIOHelper.WriteListToCSVFile(dashboardMetricSeriesAllList, new DashboardMetricSeriesReportMap(), FilePathMap.DashboardMetricSeriesIndexFilePath(jobTarget));
stepTimingTarget.NumEntities = stepTimingTarget.NumEntities + dashboardsList.Count;
#endregion
#region Combine All for Report CSV
// If it is the first one, clear out the combined folder
if (reportFolderCleaned == false)
{
FileIOHelper.DeleteFolder(FilePathMap.ControllerDashboardsReportFolderPath());
Thread.Sleep(1000);
FileIOHelper.CreateFolder(FilePathMap.ControllerDashboardsReportFolderPath());
reportFolderCleaned = true;
}
// Append all the individual report files into one
if (File.Exists(FilePathMap.DashboardsIndexFilePath(jobTarget)) == true && new FileInfo(FilePathMap.DashboardsIndexFilePath(jobTarget)).Length > 0)
{
FileIOHelper.AppendTwoCSVFiles(FilePathMap.DashboardsReportFilePath(), FilePathMap.DashboardsIndexFilePath(jobTarget));
}
if (File.Exists(FilePathMap.DashboardWidgetsIndexFilePath(jobTarget)) == true && new FileInfo(FilePathMap.DashboardWidgetsIndexFilePath(jobTarget)).Length > 0)
{
FileIOHelper.AppendTwoCSVFiles(FilePathMap.DashboardWidgetsReportFilePath(), FilePathMap.DashboardWidgetsIndexFilePath(jobTarget));
}
if (File.Exists(FilePathMap.DashboardMetricSeriesIndexFilePath(jobTarget)) == true && new FileInfo(FilePathMap.DashboardMetricSeriesIndexFilePath(jobTarget)).Length > 0)
{
FileIOHelper.AppendTwoCSVFiles(FilePathMap.DashboardMetricSeriesReportFilePath(), FilePathMap.DashboardMetricSeriesIndexFilePath(jobTarget));
}
#endregion
}
catch (Exception ex)
{
logger.Warn(ex);
loggerConsole.Warn(ex);
return(false);
}
finally
{
stopWatchTarget.Stop();
this.DisplayJobTargetEndedStatus(jobConfiguration, jobTarget, i + 1, stopWatchTarget);
stepTimingTarget.EndTime = DateTime.Now;
stepTimingTarget.Duration = stopWatchTarget.Elapsed;
stepTimingTarget.DurationMS = stopWatchTarget.ElapsedMilliseconds;
List <StepTiming> stepTimings = new List <StepTiming>(1);
stepTimings.Add(stepTimingTarget);
FileIOHelper.WriteListToCSVFile(stepTimings, new StepTimingReportMap(), FilePathMap.StepTimingReportFilePath(), true);
}
i++;
}
return(true);
}
catch (Exception ex)
{
logger.Error(ex);
loggerConsole.Error(ex);
return(false);
}
finally
{
stopWatch.Stop();
this.DisplayJobStepEndedStatus(jobConfiguration, stopWatch);
stepTimingFunction.EndTime = DateTime.Now;
stepTimingFunction.Duration = stopWatch.Elapsed;
stepTimingFunction.DurationMS = stopWatch.ElapsedMilliseconds;
List <StepTiming> stepTimings = new List <StepTiming>(1);
stepTimings.Add(stepTimingFunction);
FileIOHelper.WriteListToCSVFile(stepTimings, new StepTimingReportMap(), FilePathMap.StepTimingReportFilePath(), true);
}
}
public bool EditDashboardWidget(DashboardWidget dashboardWidget)
{
_unitOfWork.DashboardWidgetRepository.Edit(dashboardWidget);
_unitOfWork.Save();
return(true);
}
public bool EditDashboardWidget(DashboardWidget dashboardWidget)
{
_unitOfWork.DashboardWidgetRepository.Edit(dashboardWidget);
_unitOfWork.Save();
return true;
}
internal async static Task <ResponseBase> addWidget(TeamHttpContext httpContext, DashboardWidget widgetdata)
{
try
{
AddUserDashboard(new UserDashboard
{
DashboardWidgetName = widgetdata.DashboardWidgetName,
DashboardChartType = widgetdata.DashboardChartType,
DashboardUserPermission = widgetdata.DashboardUserPermission,
DashboardEmailFormat = widgetdata.DashboardEmailFormat,
WidgetConnectionString = widgetdata.WidgetConnectionString,
WidgetSchedulerType = widgetdata.WidgetSchedulerType,
WidgetSchedulerEmailIDs = widgetdata.WidgetSchedulerEmailIDs,
WidgetQuery = widgetdata.WidgetQuery,
Level1ConnectionString = widgetdata.Level1ConnectionString,
Level1SchedulerType = widgetdata.Level1SchedulerType,
L1SchedulerEmailIDs = widgetdata.L1SchedulerEmailIDs,
DashbaordQueryL1 = widgetdata.DashbaordQueryL1,
Level2ConnectionString = widgetdata.Level2ConnectionString,
Level2SchedulerType = widgetdata.Level2SchedulerType,
L2SchedulerEmailIDs = widgetdata.L2SchedulerEmailIDs,
DashbaordQueryL2 = widgetdata.DashbaordQueryL2,
Level3ConnectionString = widgetdata.Level3ConnectionString,
Level3SchedulerType = widgetdata.Level3SchedulerType,
L3SchedulerEmailIDs = widgetdata.L3SchedulerEmailIDs,
DashbaordQueryL3 = widgetdata.DashbaordQueryL3,
Level4ConnectionString = widgetdata.Level4ConnectionString,
Level4SchedulerType = widgetdata.Level4SchedulerType,
L4SchedulerEmailIDs = widgetdata.L4SchedulerEmailIDs,
DashbaordQueryL4 = widgetdata.DashbaordQueryL4,
WidgetSendEmail = widgetdata.WidgetSendEmail,
CreatedBy = httpContext.ContextUserId,
CreatedOn = DateTime.Now
});
return(GetResponse(httpContext, HttpStatusCode.OK, "Available"));
}
catch (Exception ex)
{
return(GetResponse(httpContext, HttpStatusCode.BadRequest, ex.Message.ToString()));
}
}
internal async static Task <ResponseBase> updateWidget(TeamHttpContext httpContext, DashboardWidget widgetdata)
{
try
{
List <UserDashboard> objUserDashboard = new List <UserDashboard>();
using (TeamDbContext dbContext = new TeamDbContext())
{
if (dbContext.UserDashboards.AsNoTracking().FirstOrDefault(e => e.Id == widgetdata.WidgetId) != null)
{
objUserDashboard = dbContext.UserDashboards.Where(x => x.Id == widgetdata.WidgetId && x.Deleted == false).ToList();
}
}
if (objUserDashboard.Count != 0)
{
UpdateUserDashboard(new UserDashboard
{
Id = widgetdata.WidgetId,
DashboardWidgetName = widgetdata.DashboardWidgetName,
DashboardChartType = widgetdata.DashboardChartType,
DashboardUserPermission = widgetdata.DashboardUserPermission,
DashboardEmailFormat = widgetdata.DashboardEmailFormat,
WidgetConnectionString = widgetdata.WidgetConnectionString,
WidgetSchedulerType = widgetdata.WidgetSchedulerType,
WidgetSchedulerEmailIDs = widgetdata.WidgetSchedulerEmailIDs,
WidgetQuery = widgetdata.WidgetQuery,
Level1ConnectionString = widgetdata.Level1ConnectionString,
Level1SchedulerType = widgetdata.Level1SchedulerType,
L1SchedulerEmailIDs = widgetdata.L1SchedulerEmailIDs,
DashbaordQueryL1 = widgetdata.DashbaordQueryL1,
Level2ConnectionString = widgetdata.Level2ConnectionString,
Level2SchedulerType = widgetdata.Level2SchedulerType,
L2SchedulerEmailIDs = widgetdata.L2SchedulerEmailIDs,
DashbaordQueryL2 = widgetdata.DashbaordQueryL2,
Level3ConnectionString = widgetdata.Level3ConnectionString,
Level3SchedulerType = widgetdata.Level3SchedulerType,
L3SchedulerEmailIDs = widgetdata.L3SchedulerEmailIDs,
DashbaordQueryL3 = widgetdata.DashbaordQueryL3,
Level4ConnectionString = widgetdata.Level4ConnectionString,
Level4SchedulerType = widgetdata.Level4SchedulerType,
L4SchedulerEmailIDs = widgetdata.L4SchedulerEmailIDs,
DashbaordQueryL4 = widgetdata.DashbaordQueryL4,
WidgetSendEmail = widgetdata.WidgetSendEmail,
CreatedBy = objUserDashboard[0].CreatedBy,
CreatedOn = objUserDashboard[0].CreatedOn,
ModifiedBy = httpContext.ContextUserId,
ModifiedOn = DateTime.Now
});
return(GetResponse(httpContext, HttpStatusCode.OK, "Available"));
}
return(null);
}
catch (Exception ex)
{
return(GetResponse(httpContext, HttpStatusCode.BadRequest, ex.Message.ToString()));
}
}
public DeviceLandingPage(ParticleDevice device)
{
Title = "Mission Control";
BackgroundColor = AppColors.BackgroundColor;
ViewModel = new DeviceLandingPageViewModel(device);
BindingContext = ViewModel;
var refreshDevice = new ToolbarItem {
Icon = "ic_cached_white_24dp.png"
};
var back = new ToolbarItem {
Icon = "ic_clear_white.png"
};
var layout = new RelativeLayout();
var indicator = new ActivityIndicator();
var deviceName = new StyledLabel {
CssStyle = "h1"
};
var deviceConnected = new Image {
Source = "notconnected.png"
};
var currentAppLabel = new StyledLabel {
CssStyle = "h2"
};
var variableWidget = new DashboardWidget();
var functionWidget = new DashboardWidget();
var appDescription = new StyledLabel {
CssStyle = "body"
};
var interactButton = new StyledButton
{
StyleId = "startInteractionButton",
Text = "START INTERACTION",
BackgroundColor = AppColors.Green,
CssStyle = "button",
BorderRadius = 0,
HeightRequest = AppSettings.ButtonHeight,
IsEnabled = false
};
var flashButton = new StyledButton
{
StyleId = "flashBinaryButton",
Text = "FLASH NEW APP",
BackgroundColor = AppColors.Purple,
CssStyle = "button",
BorderRadius = 0,
HeightRequest = AppSettings.ButtonHeight,
IsEnabled = false
};
var boxConstraint = Constraint.RelativeToParent(p => p.Width / 2 - AppSettings.Margin - AppSettings.ItemPadding / 2);
layout.Children.Add(deviceName,
xConstraint: Constraint.Constant(AppSettings.Margin),
yConstraint: Constraint.Constant(Device.OnPlatform(AppSettings.Margin, 10, 10)),
widthConstraint: Constraint.RelativeToParent(p => p.Width - AppSettings.Margin * 2)
);
layout.Children.Add(currentAppLabel,
xConstraint: Constraint.Constant(AppSettings.Margin),
yConstraint: Constraint.RelativeToView(deviceName, (p, v) => v.Y + v.Height + 5),
widthConstraint: Constraint.RelativeToParent(p => p.Width - AppSettings.Margin * 2),
heightConstraint: Constraint.RelativeToView(deviceName, (p, v) => v.Height)
);
layout.Children.Add(variableWidget,
xConstraint: Constraint.Constant(AppSettings.Margin),
yConstraint: Constraint.RelativeToView(currentAppLabel, (p, v) => Device.OnPlatform(
v.Y + v.Height + 5,
v.Y + v.Height,
v.Y + v.Height)
),
widthConstraint: boxConstraint,
heightConstraint: boxConstraint
);
layout.Children.Add(functionWidget,
xConstraint: Constraint.RelativeToParent(p => p.Width / 2 + AppSettings.ItemPadding / 2),
yConstraint: Constraint.RelativeToView(variableWidget, (p, v) => v.Y),
widthConstraint: boxConstraint,
heightConstraint: boxConstraint
);
layout.Children.Add(new ScrollView {
Content = appDescription
},
xConstraint: Constraint.Constant(AppSettings.Margin),
yConstraint: Constraint.RelativeToView(functionWidget, (p, v) => v.Y + v.Height + 10),
widthConstraint: Constraint.RelativeToParent(p => p.Width - AppSettings.Margin * 2),
heightConstraint: Constraint.RelativeToView(functionWidget, (p, v) => p.Height - v.Y - v.Height - 10 - AppSettings.Margin - 2 * AppSettings.ButtonHeight - 20)
);
layout.Children.Add(flashButton,
xConstraint: Constraint.Constant(AppSettings.Margin),
yConstraint: Constraint.RelativeToParent(p => p.Height - AppSettings.Margin - AppSettings.ButtonHeight),
widthConstraint: Constraint.RelativeToParent(p => p.Width - AppSettings.Margin * 2),
heightConstraint: Constraint.Constant(AppSettings.ButtonHeight)
);
layout.Children.Add(interactButton,
xConstraint: Constraint.Constant(AppSettings.Margin),
yConstraint: Constraint.RelativeToView(flashButton, (p, v) => v.Y - AppSettings.ButtonHeight - 10),
widthConstraint: Constraint.RelativeToParent(p => p.Width - AppSettings.Margin * 2),
heightConstraint: Constraint.Constant(AppSettings.ButtonHeight)
);
layout.Children.Add(indicator,
xConstraint: Constraint.Constant(AppSettings.Margin),
yConstraint: Constraint.RelativeToView(functionWidget, (p, v) => v.Y + v.Height + 10),
widthConstraint: Constraint.RelativeToParent(p => p.Width - AppSettings.Margin * 2),
heightConstraint: Constraint.RelativeToView(functionWidget, (p, v) => p.Height - v.Y - v.Height - 10 - AppSettings.Margin - 2 * AppSettings.ButtonHeight - 20)
);
variableWidget.WidgetTitle.Text = "Variables";
functionWidget.WidgetTitle.Text = "Functions";
if (Device.OS == TargetPlatform.iOS)
{
interactButton.TextColor = Color.FromHex("#ffffff");
flashButton.TextColor = Color.FromHex("#ffffff");
}
Content = layout;
ToolbarItems.Add(refreshDevice);
ToolbarItems.Add(back);
indicator.SetBinding(ActivityIndicator.IsRunningProperty, "IsBusy");
if (Device.OS != TargetPlatform.iOS && Device.OS != TargetPlatform.Android)
{
indicator.SetBinding(ActivityIndicator.IsVisibleProperty, "IsBusy");
}
deviceName.SetBinding(Label.TextProperty, "Device.Name");
currentAppLabel.SetBinding(Label.TextProperty, "CurrentApp");
deviceConnected.SetBinding(Image.IsVisibleProperty, "DeviceConnected");
variableWidget.WidgetCount.SetBinding(Label.TextProperty, "VariableCount");
functionWidget.WidgetCount.SetBinding(Label.TextProperty, "FunctionCount");
interactButton.SetBinding(Button.IsEnabledProperty, "InteractButtonLock");
flashButton.SetBinding(Button.IsEnabledProperty, "FlashButtonLock");
refreshDevice.SetBinding(ToolbarItem.CommandProperty, "RefreshDeviceCommand");
appDescription.SetBinding(Label.TextProperty, "AppDescription");
interactButton.Clicked += async(object sender, EventArgs e) =>
{
if (ViewModel.CurrentApp.ToLower().Contains("rgb led picker"))
{
await Navigation.PushAsync(new ChangeLEDColorPage(ViewModel.Device, ViewModel.variables));
}
else if (ViewModel.CurrentApp.ToLower().Contains("simonsays"))
{
await Navigation.PushAsync(new SimonSaysPage(ViewModel.Device));
}
else
{
DisplayAlert("Sorry...", "There isn't a mobile interaction with this IoT app. Try flashing either the 'Simon Says' or ' RBG LED' app.", "Ok");
}
};
flashButton.Clicked += async(object sender, EventArgs e) =>
{
var result = await DisplayActionSheet("Pick File to Flash", "Cancel", null, "RGB LED", "Shake LED", "Simon Says", "Follow me LED");
if (result != "Cancel")
{
var success = await ViewModel.TryFlashFileAsync(result);
if (!success)
{
await DisplayAlert("Error", "The Device connection timed out. Please try again once the device breaths a solid cyan light", "Ok");
}
}
};
back.Clicked += async(object sender, EventArgs e) =>
{
var success = await ViewModel.Device.UnclaimAsync();
//if (success)
Navigation.PopModalAsync(true);
};
}
