public void ProcessRequest(HttpContext context)
{
DashboardInfo nDashboardInfo = bllDashboard.GetByKey <DashboardInfo>("WebsiteOwner", bllDashboard.WebsiteOwner);
if (nDashboardInfo == null)
{
apiResp.result = new DashboardJson();
apiResp.msg = "没有该站点数据";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.IsNotFound;
bllDashboard.ContextResponse(context, apiResp);
return;
}
JToken dashJson = JToken.Parse(nDashboardInfo.Json);
//dashJson["uv_total"] = bllDashboard.GetDashboardUVTotal(bllDashboard.WebsiteOwner);
//dashJson["order_total"] = bllDashboard.GetDashboardOrderTotal(bllDashboard.WebsiteOwner, "0,1,2,3");
//dashJson["member_total"] = bllDashboard.GetDashboardRegUserTotal(bllDashboard.WebsiteOwner);
//dashJson["fans_total"] = bllDashboard.GetDashboardSubscribeTotal(bllDashboard.WebsiteOwner);
//dashJson["visit_total"] = bllDashboard.GetDashboardMonitorEventDetailsTotal(bllDashboard.WebsiteOwner);
dashJson["fans_total"] = bllWeixin.GetFollowerTotalCount(bllWeixin.WebsiteOwner);
var uvTotal = Convert.ToInt32(dashJson["uv_total"]);
if (bllDashboard.WebsiteOwner == "comeoncloud")
{
dashJson["uv_total"] = uvTotal + 30000;
}
apiResp.result = dashJson;
apiResp.msg = "查询完成";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.IsSuccess;
apiResp.status = true;
bllDashboard.ContextResponse(context, apiResp);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.NavigationMode == NavigationMode.Back && PhoneApplicationService.Current.State.ContainsKey("sessionTimedout"))
{
return;
}
if ((e.NavigationMode == NavigationMode.Back) && (e.Content.GetType() == typeof(Dashboard)))
{
try
{
ServiceInvoker.InvokeServiceUsingGet("/api/t360/Invoice/GetDashboardInfo", delegate(object a, ServiceEventArgs serviceEventArgs)
{
ServiceResponse result = serviceEventArgs.Result;
DashboardInfo dashBoardInfo = JsonConvert.DeserializeObject <DashboardInfo>(result.Output);
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
string invoiceCount = UserData.Instance.AwaitingInvoiceCount = dashBoardInfo.InvoiceCount;
invoiceCountLabel.FontSize = 72;
if (invoiceCount.Length > 2)
{
invoiceCountLabel.FontSize = 48;
}
invoiceCountLabel.Text = UserData.Instance.AwaitingInvoiceCount;
});
}, false);
}
catch (Exception ex)
{
ShowError((AppException)ex);
}
}
}
public async Task <DashboardInfo> GetInfo()
{
string connectionString = configuration.GetConnectionString("Default");
var commandText = "dash.GetDashboardInfo";
// var param = new { userId };
var command = new CommandDefinition(commandText, commandType: CommandType.StoredProcedure);
DashboardInfo info;
try
{
using SqlConnection connection = new SqlConnection(connectionString);
var result = connection.QueryMultiple(command);
info = new DashboardInfo();
info.Pharmacies = await result.ReadFirstAsync <int>();
info.Patients = await result.ReadFirstAsync <int>();
info.Prescriptions = await result.ReadFirstAsync <int>();
info.Delivered = await result.ReadFirstAsync <int>();
info.ActivePharmacies = await result.ReadAsync <ActivePharmacy>();
info.DailyPrescriptions = await result.ReadAsync <DailyPrescription>();
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessage());
info = null;
}
return(info);
}
// all incoming command are handled here
private void HandleIncomingCommand(PacketHeader packetHeader, Connection connection, VRCommand vrCommand)
{
switch (vrCommand.ControlMessage)
{
case Enums.ControlMessage.UNITY_DASHBOARD_GETRUNNINGGAMES:
//Debug.Log(connection + Environment.NewLine + " Get Running Games");
if (vrCommand.RunningGameInfo != null && vrCommand.RunningGameInfo.IsPostTerminationCheck)
{
// post termination check
//SendRunningGames(true);
}
else
{
//SendRunningGames(false);
}
break;
case Enums.ControlMessage.UNITY_DASHBOARD_SETDASHINFO:
dashboardInfo = vrCommand.DashboardInfo;
break;
default:
break;
}
}
public override void InitControl(bool showSplash)
{
if (showSplash)
{
FormProgress.ShowProgress("Loading data...", DashboardInfo.LoadContentData);
}
else
{
DashboardInfo.LoadContentData();
}
_slides.Add(new CleanslateControl(this));
_slides.Add(new CoverControl(this));
_slides.Add(new LeadoffStatementControl(this));
_slides.Add(new ClientGoalsControl(this));
_slides.Add(new TargetCustomersControl(this));
_slides.Add(new SimpleSummaryControl(this));
xtraTabControl.TabPages.AddRange(_slides.OfType <XtraTabPage>().ToArray());
xtraTabControl.SelectedTabPage = _slides.FirstOrDefault();
xtraTabControl.SelectedPageChanged += OnSelectedSlideChanged;
foreach (var slideControl in _slides)
{
AssignCloseActiveEditorsOnOutsideClick(slideControl);
}
}
public override async Task LoadData(params object[] parameters)
{
if (parameters != null)
{
if (parameters[0] != null)
{
LoginInfo = (LoginInfo)parameters[0];
MemberName = UserPreference.Instance.CurrentUserName = LoginInfo.MemberName;
PushNotification.UpdateTile(LoginInfo.InvoiceCount);
UserPreference.Instance.IsClientOrTymetrixUser = LoginInfo.IsClientOrTymetrixUser;
UserPreference.Instance.HasInvoiceListAccess = LoginInfo.HasInvoiceListAccess;
DashboardInfo = new DashboardInfo()
{
InvoiceCount = LoginInfo.InvoiceCount
};
SaveUserDetails();
}
else
{
try
{
IsBusy = true;
DashboardInfo = await ServiceInvoker.Instance.InvokeServiceUsingGet <DashboardInfo>(ServiceInvoker.Instance.AppendUrl(ServiceInvoker.GetDashboardInfoService));
MemberName = UserPreference.Instance.CurrentUserName;
IsBusy = false;
}
catch (T360Exception ex)
{
string message = getMessages(ex);
ShowErrorMessage(message, Constants.DashboardFailed);
}
}
}
}
public IActionResult Info()
{
var info = new DashboardInfo();
info.Jobs = _JobsManager.GetDashboardInfo();
info.Deals = _DealsManager.GetDashboardInfo();
return(Ok(info));
}
public Task <ActionResult> Index()
{
return(Task.Run(() =>
{
DashboardInfo info = new DashboardInfo();
return View(info) as ActionResult;
}));
}
public DashboardInfo Get()
{
DashboardInfo dashboardInfo = new DashboardInfo();
dashboardInfo.EmployeeCount = unitOfWork.employeeRepository.GetAll().Count();
dashboardInfo.DepartmentCount = unitOfWork.departmentRepository.GetAll().Count();
return(dashboardInfo);
}
/// <summary>
/// 更新展示数据
/// </summary>
/// <param name="websiteOwner"></param>
/// <param name="date"></param>
/// <param name="json"></param>
/// <returns></returns>
public bool UpdateDashboardInfo(string websiteOwner, int date, string json)
{
DashboardInfo nInfo = GetColByKey <DashboardInfo>("WebsiteOwner", websiteOwner, "WebsiteOwner");
nInfo.Date = date;
nInfo.Json = json;
return(Update(nInfo));
}
public Task <ActionResult> GetDetailInfo()
{
return(Task.Run(() =>
{
DashboardInfo info = new DashboardInfo();
string content = JsonConvert.SerializeObject(info);
return Content(content) as ActionResult;
}));
}
private async Task LoadDailyReports(DashboardInfo dashboard)
{
var weekDailyReports =
0.To(7)
.Select(async i => await GetDailyReport(DateTime.Now.Subtract(TimeSpan.FromDays(i + 1))))
.ToList();
var reports = await Task.WhenAll(weekDailyReports);
dashboard.LastWeekDailyReports = new ObservableCollection <MobfoxReport>(reports.OrderBy(e => e.StartTime));
}
private void backgroundMetrics_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = (BackgroundWorker)sender;
while (!worker.CancellationPending)
{
DashboardInfo dashboardInfo = GetInfo();
worker.ReportProgress(0, dashboardInfo);
Thread.Sleep(200);
}
}
// Gets information about dashboards available in a DataSet.
public IEnumerable <DashboardInfo> GetAvailableDashboardsInfo()
{
List <DashboardInfo> dashboardInfos = new List <DashboardInfo>();
foreach (DataRow row in dashboards.Tables[0].Rows)
{
DashboardInfo dashboardInfo = new DashboardInfo();
dashboardInfo.ID = row["DashboardID"].ToString();
dashboardInfo.Name = row["DashboardName"].ToString();
dashboardInfos.Add(dashboardInfo);
}
return(dashboardInfos);
}
private void backgroundMetrics_DoWork(object sender, DoWorkEventArgs e)
{
//Instance Function from MonitoringFunctions Class
var monitoring = new System_Monitoring();
BackgroundWorker worker = (BackgroundWorker)sender;
while (!worker.CancellationPending)
{
//overallServerStatsGrid.Rows.Clear();
Thread.Sleep(500);
_dashboardInfo = GetInfo();
worker.ReportProgress(0, "AN OBJECT TO PASS TO THE UI-THREAD");
}
}
public async Task <ActionResult> GetDashboardInfo()
{
var dashboardCollectorGrain = GrainClient.GrainFactory.GetGrain <IDashboardCollectorGrain>(Guid.Empty);
var types = await dashboardCollectorGrain.GetGrainTypes();
var dashboardInfo = new DashboardInfo
{
Silos = await dashboardCollectorGrain.GetSilos(),
AvailableTypes = types
};
return(Json(dashboardInfo, JsonRequestBehavior.AllowGet));
}
private void RefreshUI(DashboardInfo info)
{
progressRAMUsage.Value = (int)((info.RAM / (double)info.TotalRAM) * 100);
lblDetailedRAMUsage.Text = string.Format("{0:0.00} GB / {1:0.00} GB", info.RAM / 1024.0, info.TotalRAM / 1024.0);
progressDISKUsage.Value = (int)(info.DiskUsed / info.DiskTotal * 100);
lblDetailedDISKUsage.Text = string.Format("{0:0.00} GB / {1:0.00} GB", info.DiskUsed, info.DiskTotal);
progressCPUUsage.Value = (int)(info.CPU);
lblDetailedCPUUsage.Text = string.Format("{0}% @ {1}-Cores", info.CPU, Environment.ProcessorCount);
progressLANUsage.Value = (int)(info.LAN_DOWN); //PLACEHOLDER 0 Kb/s RX / 0 Kb/s TX
lblDetailedLANUsage.Text = string.Format("{0} Kb/s TX {1} Kb/s RX", Convert.ToString(info.LAN_UP), Convert.ToString(info.LAN_DOWN));
}
public List <DashboardInfo> LoadDashboard(string bayid)
{
DashboardInfo ci = new DashboardInfo();
List <DashboardInfo> DashboardInformation = new List <DashboardInfo>();
DataSet ds;
using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["connstr"].ToString()))
{
using (SqlCommand cmd = new SqlCommand("SP_DashboardDisplay", con))
{
con.Open();
cmd.Connection = con;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@BayID", SqlDbType.Int).Value = Convert.ToInt32(bayid);
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
ds = new DataSet();
da.Fill(ds);
}
}
}
try
{
if (ds != null)
{
if (ds.Tables.Count > 0)
{
if (ds.Tables[0].Rows.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
DashboardInformation.Add(new DashboardInfo()
{
ServiceName = dr["ServiceName"].ToString(),
RoomNo = dr["RoomNo"].ToString(),
QueueNo = dr["QueueNo"].ToString()
});
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return(DashboardInformation);
}
//===================================================================================//
// DASHBOARD: //
//===================================================================================//
private DashboardInfo GetInfo()
{
var monitoring = new System_Monitoring();
var rtn = new DashboardInfo();
rtn.TotalRAM = monitoring.RetreiveTotalAvailableRAM();
rtn.RAM = monitoring.RetreiveTotalAvailableRAM() - monitoring.RetreiveFreeRAM();
rtn.DiskUsed = monitoring.RetrieveDISKInfo(@"C:\", false, true, false);
rtn.DiskTotal = monitoring.RetrieveDISKInfo(@"C:\", true, false, false);
rtn.CPU = monitoring.RetrieveCPUUsage();
rtn.LAN_DOWN = monitoring.RetrieveLANUsage(true, false);
rtn.LAN_UP = monitoring.RetrieveLANUsage(false, true);
return(rtn);
}
//===================================================================================//
// DASHBOARD: //
//===================================================================================//
private DashboardInfo GetInfo()
{
var dashboardInfo = new DashboardInfo
{
TotalRAM = _systemMonitoring.RetreiveTotalAvailableRAM(),
RAM = _systemMonitoring.RetreiveTotalAvailableRAM() - _systemMonitoring.RetreiveFreeRAM(),
DiskUsed = _systemMonitoring.RetrieveDISKInfo(@"C:\", false, true, false),
DiskTotal = _systemMonitoring.RetrieveDISKInfo(@"C:\", true, false, false),
CPU = _systemMonitoring.RetrieveCPUUsage(),
LAN_DOWN = _systemMonitoring.RetrieveLANUsage(true, false),
LAN_UP = _systemMonitoring.RetrieveLANUsage(false, true)
};
return(dashboardInfo);
}
public async Task<ActionResult> GetDashboardInfo()
{
var clusterClient = await GrainClientMultiton.GetAndConnectClient(GrainSessionId);
var dashboardCollectorGrain = clusterClient.GetGrain<IDashboardCollectorGrain>(Guid.Empty);
var types = await dashboardCollectorGrain.GetGrainTypes();
var dashboardInfo = new DashboardInfo
{
Silos = await dashboardCollectorGrain.GetSilos(),
AvailableTypes = types
};
return Json(dashboardInfo, JsonRequestBehavior.AllowGet);
}
private async Task LoadDashboardAsync()
{
var dashboard = new DashboardInfo();
Func <Task> todayMethod = async() =>
{
dashboard.TodaysReport =
await GetTodayReport();
};
Func <Task> thisWeek = async() =>
{
dashboard.ThisWeekReport =
await GetThisWeekReport();
};
Func <Task> lastWeek = async() =>
{
dashboard.LastWeekReport =
await GetLastWeekReport();
};
Func <Task> thisMonth = async() =>
{
dashboard.ThisMonthReport =
await GetThisMonthReport();
};
Func <Task> lastMonth = async() =>
{
dashboard.LastMonthReport =
await GetLastMonthReport();
};
await Task.WhenAll(
new[] {
todayMethod(),
thisWeek(),
lastWeek(),
thisMonth(),
lastMonth()
}
);
await LoadDailyReports(dashboard);
DashboardInfo = dashboard;
}
public DashboardInfo GetDashboardInfo(DateTime?recentlyFilter = null)
{
if (!recentlyFilter.HasValue)
{
recentlyFilter = _timeProvider.GetUtcNow().AddHours(-1);
}
var res = new DashboardInfo
{
WaitingJobs = _jobRepository.WaitingJobs().Select(Mapper.Map <DashboardJob>),
ActiveJobs = _jobRepository.ActiveJobs().Select(Mapper.Map <DashboardJob>),
RecentlyDoneJobs = _jobRepository.DoneJobs(recentlyFilter).Select(Mapper.Map <DashboardJob>),
RecentlyFailedJobs = _jobRepository.FailedJobs(recentlyFilter).Select(Mapper.Map <DashboardJob>),
RecentlyCanceledJobs = _jobRepository.CanceledJobs(recentlyFilter).Select(Mapper.Map <DashboardJob>),
Plugins = _plugins.Select(Mapper.Map <DashbaordPlugin>)
};
return(res);
}
public DashboardInfo GetDashBoardInfo()
{
DashboardInfo dashboardInfo = new DashboardInfo();
dbHelper.CreateCommand("getdashboardstats", System.Data.CommandType.StoredProcedure);
using (IDataReader dr = dbHelper.ExecuteReader())
{
dashboardInfo.ShiftSummary = new List <ShiftDashboardInfo>();
string str = String.Empty;
ShiftDashboardInfo prev = null;
while (dr.Read())
{
string shiftname = dr["shiftname"].ToString();
bool IsReturnTrip = !Convert.ToBoolean(dr["IsPickUpTrip"]);
ShiftRowInfo shiftRow = new ShiftRowInfo();
shiftRow.NoOfEmployeesBoarded = Convert.ToInt32(dr["BoardedMembers"]);
int totalPlanned = Convert.ToInt32(dr["TotalPlanned"]);
shiftRow.NoOfVechiles = Convert.ToInt32(dr["VechileCount"]);
shiftRow.Status = dr["currentstatus"].ToString();
shiftRow.NoOfEmployeesNoShow = shiftRow.Status.ToUpper() == "COMPLETED" ? totalPlanned - shiftRow.NoOfEmployeesBoarded : 0;
shiftRow.NoOfEmployeesYetToBoard = shiftRow.Status.ToUpper() != "COMPLETED" ? totalPlanned - shiftRow.NoOfEmployeesBoarded : 0;
shiftRow.ShiftPickStartTime = dr["ShiftStartTime"].ToString();
if (str != shiftname)
{
str = shiftname;
prev = new ShiftDashboardInfo();
prev.ShiftName = shiftname;
dashboardInfo.ShiftSummary.Add(prev);
}
if (IsReturnTrip)
{
prev.ReturnTrip = shiftRow;
}
else
{
prev.PickUpTrip = shiftRow;
}
}
}
return(dashboardInfo);
}
IEnumerable <DashboardInfo> IDashboardStorage.GetAvailableDashboardsInfo()
{
List <DashboardInfo> dashboardInfos = new List <DashboardInfo>();
foreach (DataRow row in dashboards.Tables[0].Rows)
{
var dashboardId = row[dashboardIDColumn].ToString();
if (IsAuthorized(dashboardId))
{
DashboardInfo dashboardInfo = new DashboardInfo {
ID = row[dashboardIDColumn].ToString(),
Name = row[nameColumn].ToString()
};
dashboardInfos.Add(dashboardInfo);
}
}
return(dashboardInfos);
}
public ActionResult SystemDashboard()
{
try
{
dynamic response = JObject.Parse(GetResponse(string.Format("/GetSystemDetails/{0}", "zoneA")));
if (response.status > 0)
{
DashboardInfo dashboardInfo = JsonConvert.DeserializeObject <DashboardInfo>(response.data.ToString());
var dashboardInfoFromDB = new DashboardInfo();
using (var ibisaRepository = new IBISARepository())
{
dashboardInfoFromDB.AgreementDetails = ibisaRepository.GetAgreements();
}
//if (dashboardInfo.AgreementDetails != null && dashboardInfo.AgreementDetails.Any())
// dashboardInfo.totalUsers = dashboardInfo.AgreementDetails.Count;
if (dashboardInfo.AgreementDetails != null && dashboardInfoFromDB.AgreementDetails != null && dashboardInfo.AgreementDetails.Any() && dashboardInfoFromDB.AgreementDetails.Any())
{
dashboardInfoFromDB.AgreementDetails.ForEach(x =>
{
var agreement = dashboardInfo.AgreementDetails.FirstOrDefault(i => i.wallet_address == x.wallet_address);
if (agreement != null)
{
agreement.agreementPrimaryId = x.agreementPrimaryId;
agreement.agreementNumber = x.agreementNumber;
agreement.zone = x.zone;
}
});
}
return(View(dashboardInfo));
}
}
catch (Exception ex)
{
ExceptionHelper.Log("Method: SystemDashboard()", ex);
}
return(View(new DashboardInfo()));
}
public ActionResult Index()
{
DashboardInfo dInfo = DashboardService.GetDashBoardInfo();
return View(dInfo.ShiftSummary);
}
private void RefreshUI(DashboardInfo info)
{
if (info == null)
{
return;
}
//Animate the color of the RAM progress bar circle.
if (progressRAMUsage.Value <= 50)
{
progressRAMUsage.ProgressColor = Color.FromArgb(67, 181, 129);
}
if (progressRAMUsage.Value > 50)
{
progressRAMUsage.ProgressColor = Color.FromArgb(231, 145, 50);
}
if (progressRAMUsage.Value > 80)
{
progressRAMUsage.ProgressColor = Color.FromArgb(191, 45, 66);
}
//Animate the color of the CPU progress bar circle.
if (progressCPUUsage.Value <= 50)
{
progressCPUUsage.ProgressColor = Color.FromArgb(67, 181, 129);
}
if (progressCPUUsage.Value > 50)
{
progressCPUUsage.ProgressColor = Color.FromArgb(231, 145, 50);
}
if (progressCPUUsage.Value > 80)
{
progressCPUUsage.ProgressColor = Color.FromArgb(191, 45, 66);
}
//Animate the color of the DISK progress bar circle.
if (progressDISKUsage.Value <= 50)
{
progressDISKUsage.ProgressColor = Color.FromArgb(67, 181, 129);
}
if (progressDISKUsage.Value > 50)
{
progressDISKUsage.ProgressColor = Color.FromArgb(231, 145, 50);
}
if (progressDISKUsage.Value > 80)
{
progressDISKUsage.ProgressColor = Color.FromArgb(191, 45, 66);
}
progressRAMUsage.Value = (int)((info.RAM / (double)info.TotalRAM) * 100);
lblDetailedRAMUsage.Text = string.Format("{0:0.00} GB / {1:0.00} GB", info.RAM / 1024.0, info.TotalRAM / 1024.0);
progressDISKUsage.Value = (int)(info.DiskUsed / info.DiskTotal * 100);
lblDetailedDISKUsage.Text = string.Format("{0:0.00} GB / {1:0.00} GB", info.DiskUsed, info.DiskTotal);
progressCPUUsage.Value = (info.CPU);
lblDetailedCPUUsage.Text = string.Format("{0}% @ {1}-Cores", info.CPU, Environment.ProcessorCount);
progressLANUsage.Value = (int)(info.LAN_DOWN); //PLACEHOLDER 0 Kb/s RX / 0 Kb/s TX
lblDetailedLANUsage.Text = string.Format("{0} Kb/s TX {1} Kb/s RX", info.LAN_UP, info.LAN_DOWN);
}
public async Task Load()
{
DashboardInfo = await _storage.Load();
}
public async Task RefreshDashboard(DashboardInfo dashboardInfo)
{
await this.hubContext.Clients.All.SendAsync("RefreshData", dashboardInfo);
}
