private void CreateServerDownEvent(ServerDataViewModel sdvm)
{
try
{
Model.EventType type = Facade.EventTypeDomainController.GetTypeByName(StaticStrings.ServerDown);
int serverInterval = Facade.SettingDomainController.GetValueByName(StaticStrings.ServerDetailInterval);
RequestSummary requestSummary = Facade.RequestSummaryDomainController.GetRequestSummaryLastMinutes(serverInterval);
ServerDetail latestServerDetailSummary = Facade.ServerDetailDomainController.GetLatestServerDetailByInterval(serverInterval + (serverInterval / 2));
Notification n = new Notification();
n.Seen = false;
n = Facade.NotificationDomainController.Create(n);
Model.Event e = new Model.Event();
e.Created = DateTime.Now;
e.Value = 1;
e.EventTypeId = type.Id;
e.RequestSummaryId = requestSummary == null ? 0 : requestSummary.Id;
e.ServerDetailId = latestServerDetailSummary == null ? 0 : latestServerDetailSummary.Id;
e.NotificationId = n.Id;
Facade.EventDomainController.Create(e);
sdvm.Uptime = CalculateUpTime(0);
sdvm.CurrentStatus = false;
}
catch (Exception e)
{
log.Error("ServerLogic - CreateServerDownEvent: " + e);
}
}
public int Event_Save(Model.Event evnt)
{
int eventId = 0;
using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["constr"].ToString()))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandText = "usp_HR_Event_Save";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@EventId", evnt.EventId).Direction = ParameterDirection.InputOutput;
cmd.Parameters.AddWithValue("@EventTypeId", evnt.EventTypeId);
cmd.Parameters.AddWithValue("@EventName", evnt.EventName);
cmd.Parameters.AddWithValue("@Description", evnt.Description);
cmd.Parameters.AddWithValue("@EventStartDate", evnt.EventStartDate);
cmd.Parameters.AddWithValue("@EventEndDate", evnt.EventEndDate);
cmd.Parameters.AddWithValue("@BranchId", evnt.BranchId);
cmd.Parameters.AddWithValue("@Venue", evnt.Venue);
cmd.Parameters.AddWithValue("@CreatedBy", evnt.CreatedBy);
if (con.State == ConnectionState.Closed)
{
con.Open();
}
cmd.ExecuteNonQuery();
eventId = Convert.ToInt32(cmd.Parameters["@EventId"].Value);
con.Close();
}
}
return(eventId);
}
private static Event CreateProtobufEvent(Model.Event ev)
{
return(new Event
{
Id = ev.ID,
AgeMin = ev.AgeMin,
AgeMax = ev.AgeMax,
Distance = ev.Distance,
No = ev.No
});
}
public async Task<IHttpActionResult> Post(Event e)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
e.UserId = UserId;
await DB.AddEvent(e);
return Ok(new { Id = e.Id});
}
private void writeFields(Model.Event userEvent)
{
txtName.Text = userEvent.EventName;
txtDescription.Text = userEvent.EventDescription;
dtpDate.Value = (DateTime)userEvent.EventDate;
dtpStartingTime.Value = (DateTime)userEvent.EventStartingTime;//doradit
dtpEndingTime.Value = (DateTime)userEvent.EventEndingTime;
cbEveryoneCanEnter.Checked = (bool)userEvent.AnyoneCanEnter;
numUserCanEnterBefore.Value = (decimal)userEvent.UserCanEnterBeforeEventMi;
numUserCanEnterAfter.Value = (decimal)userEvent.UserCanEnterAfterEventSta;
cbEventMaster.SelectedValue = userEvent.EventMasterId;
cbEventType.SelectedValue = userEvent.EventTypeId;
lblEventGroupId.Text = userEvent.EventGroupId;
}
private void UpdateValueAndUptime(ServerDataViewModel sdvm, Model.Event lastUpOrDownEvent)
{
try
{
if (lastUpOrDownEvent != null)
{
TimeSpan ts = DateTime.Now.Subtract(lastUpOrDownEvent.Created); //the time between the event was created and now.
decimal time = Convert.ToDecimal(ts.TotalSeconds); //convert to totalminutes
lastUpOrDownEvent.Value = Convert.ToInt32(ts.TotalMinutes); //update current value
sdvm.Uptime = CalculateUpTime(time); //update uptime
Facade.EventDomainController.UpdateEvent(lastUpOrDownEvent);
}
}
catch (Exception e)
{
log.Error("ServerLogic - UpdateValueAndUptime: " + e);
}
}
/// <summary>
/// Hooks up the specified comic event to the planet.
/// </summary>
/// <param name="comicEvent">The comic event.</param>
public void HookUp(Event comicEvent)
{
this.comicEvent = comicEvent;
this.SetName(this.comicEvent.Title);
this.SetImage(this.comicEvent.Thumbnail);
this.SetSummaries(this.CharactersSatellite, this.comicEvent.Characters);
this.SetSummaries(this.ComicsSatellite, this.comicEvent.Comics);
this.SetSummaries(this.CreatorsSatellite, this.comicEvent.Creators);
this.SetSummaries(this.SeriesSatellite, this.comicEvent.Series);
DataList<Summary> next = null;
if (this.comicEvent.Next != null &&
this.comicEvent.Next.HasData)
{
next = new DataList<Summary>()
{
Available = 1,
Returned = 1,
Items = new Summary[] { this.comicEvent.Next }
};
}
this.SetSummaries(this.NextEventSatellite, next);
DataList<Summary> previous = null;
if (this.comicEvent.Previous != null &&
this.comicEvent.Previous.HasData)
{
previous = new DataList<Summary>()
{
Available = 1,
Returned = 1,
Items = new Summary[] { this.comicEvent.Previous }
};
}
this.SetSummaries(this.PreviousEventSatellite, previous);
}
private Model.Event readFields()
{
Model.Event newEvent = new Model.Event()
{
EventName = txtName.Text,
EventDescription = txtDescription.Text,
//EventDate = dtpDate.Value,
//EventStartingTime = dtpStartingTime.Value,
//EventEndingTime = dtpEndingTime.Value,
AnyoneCanEnter = cbEveryoneCanEnter.Checked,
UserCanEnterBeforeEventMi = (int)numUserCanEnterBefore.Value,
UserCanEnterAfterEventSta = (int)numUserCanEnterAfter.Value,
EventMasterId = (int)cbEventMaster.SelectedValue,
EventTypeId = (int)cbEventType.SelectedValue,
EventGroupId = lblEventGroupId.Text.ToString()
};
newEvent.EventDate = new DateTime(dtpDate.Value.Year, dtpDate.Value.Month, dtpDate.Value.Day, 0, 0, 0);
newEvent.EventStartingTime = new DateTime(dtpDate.Value.Year, dtpDate.Value.Month, dtpDate.Value.Day, dtpStartingTime.Value.Hour, dtpStartingTime.Value.Minute, 0, 0);
newEvent.EventEndingTime = new DateTime(dtpDate.Value.Year, dtpDate.Value.Month, dtpDate.Value.Day, dtpEndingTime.Value.Hour, dtpEndingTime.Value.Minute, 0, 0);
return(newEvent);
}
public Event AddEvent(string eventName, string eventDescription, long year)
{
var historicalEvent = new Event(eventName, eventDescription, year);
Events.Add(historicalEvent);
return historicalEvent;
}
public DataTable Event_GetAll(Model.Event evnt)
{
using (DataTable dt = new DataTable())
{
using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["constr"].ToString()))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "usp_HR_Event_GetAll";
if (evnt.EventId == 0)
{
cmd.Parameters.AddWithValue("@EventId", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@EventId", evnt.EventId);
}
if (evnt.EventTypeId == 0)
{
cmd.Parameters.AddWithValue("@EventTypeId", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@EventTypeId", evnt.EventTypeId);
}
if (string.IsNullOrEmpty(evnt.EventName))
{
cmd.Parameters.AddWithValue("@EventName", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@EventName", evnt.EventName);
}
if (evnt.EventStartDate == DateTime.MinValue)
{
cmd.Parameters.AddWithValue("@EventFromDate", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@EventFromDate", evnt.EventStartDate);
}
if (evnt.EventEndDate == DateTime.MinValue)
{
cmd.Parameters.AddWithValue("@EventToDate", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@EventToDate", evnt.EventEndDate);
}
if (evnt.BranchId == 0)
{
cmd.Parameters.AddWithValue("@BranchId", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@BranchId", evnt.BranchId);
}
if (string.IsNullOrEmpty(evnt.Venue))
{
cmd.Parameters.AddWithValue("@Venue", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@Venue", evnt.Venue);
}
if (con.State == ConnectionState.Closed)
{
con.Open();
}
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
da.Fill(dt);
}
con.Close();
}
}
return(dt);
}
}
public int Event_Save(Model.Event evnt)
{
return(_Event.Event_Save(evnt));
}
public DataTable Event_GetAll(Model.Event evnt)
{
return(_Event.Event_GetAll(evnt));
}
public ServerDataViewModel GetServerData(int serverId)
{
ServerDataViewModel sdvm = new ServerDataViewModel();
try
{
sdvm.NetworkViewModel = new NetworkViewModel();
//Graph data
sdvm.CPUUtilizationGraphData = GenerateGraphData(serverId);
//Servers available (for dropdown)
sdvm.Servers = GetServers(); // USER ID LATER
sdvm.Created = DateTime.Now;
//SHOW SUMMARY - USE THIS CODE
//int serverInterval = Facade.SettingDomainController.GetValueByName(StaticStrings.ServerDetailInterval);
//ServerDetail latestServerDetails = Facade.ServerDetailDomainController.GetLatestServerDetailByInterval(serverInterval);
ServerDetailCurrent latestServerDetails = Facade.ServerDetailCurrentDomainController.GetLatest();
if (latestServerDetails != null)
{
sdvm.CurrentStatus = true;
sdvm.Handles = latestServerDetails.Handles;
sdvm.Threads = latestServerDetails.Thread;
// sdvm.Uptime = CalculateUpTime(latestServerDetails.UpTime); The computer uptime,
sdvm.RAMAvailable = Convert.ToInt32(latestServerDetails.RAMAvailable);
sdvm.Processes = latestServerDetails.Processes;
sdvm.RAMTotal = Convert.ToInt32(latestServerDetails.RAMTotal);
sdvm.NetworkViewModel.NetworkUtilization = latestServerDetails.NetworkUtilization;
}
//Should refactors
int interval = Facade.SettingDomainController.GetValueByName(StaticStrings.ServerDetailInterval);
List <ServerDetail> serverDetail = Facade.ServerDetailDomainController.GetOneDayServerDetail(serverId);
if (serverDetail != null && serverDetail.Count > 0)
{
sdvm.NetworkViewModel.Download = serverDetail.Sum(x => x.BytesReceived);
sdvm.NetworkViewModel.Upload = serverDetail.Sum(x => x.BytesSent);
int totalReceived = serverDetail.Max(x => x.BytesReceived);
int totalSent = serverDetail.Max(x => x.BytesSent);
string totalReceivedFormatted = SizeSuffix(totalReceived, 1) + "/S";
string totalSentFormatted = SizeSuffix(totalSent, 1) + "/S";
sdvm.NetworkViewModel.PeakDownloadString = totalReceivedFormatted;
sdvm.NetworkViewModel.PeakUploadString = totalSentFormatted;
sdvm.NetworkViewModel.NetworkUtilization = Convert.ToInt32(serverDetail.Average(x => x.NetworkUtilization));
}
bool dataLastMinut = Facade.ServerDetailCurrentDomainController.HasAchievedDataLastFifteenSeconds();
//get last up/down event and assign ServerStatus to this.
var lastDown = Facade.EventDomainController.GetLatestServerDownEvent();
var lastUp = Facade.EventDomainController.GetLatestServerUpEvent();
bool ServerStatus = dataLastMinut;
if (lastUp != null && lastDown != null)
{
if (lastDown.Created > lastUp.Created)
{
ServerStatus = false;
}
else
{
ServerStatus = true;
}
}
if (!dataLastMinut) //Server considered down
{
if (ServerStatus) // If serverstatus was up, then it just went down and should create event
{
ServerStatus = false;
CreateServerDownEvent(sdvm); //Create event, and finish last server up event
Model.Event lastUpEvent = Facade.EventDomainController.GetLatestServerUpEvent();
if (lastUpEvent != null)
{
TimeSpan ts = DateTime.Now.Subtract(lastUpEvent.Created);
lastUpEvent.Value = Convert.ToInt32(ts.TotalMinutes);
Facade.EventDomainController.UpdateEvent(lastUpEvent);
}
else
{
CreateServerUpEvent(sdvm);
}
}
else //Server down and last serverstatus was false, we just update the last downevents value, and the "downtime"
{
Model.Event lastDownEvent = Facade.EventDomainController.GetLatestServerDownEvent();
if (lastDownEvent != null)
{
UpdateValueAndUptime(sdvm, lastDownEvent);
}
else
{
CreateServerDownEvent(sdvm);
}
}
}
else //Server is up
{
if (!ServerStatus) // If serverstatus was down, then it just went up and should create event
{
ServerStatus = true;
CreateServerUpEvent(sdvm); //Create event, and finish last server up event
Model.Event lastDownEvent = Facade.EventDomainController.GetLatestServerDownEvent();
if (lastDownEvent != null)
{
TimeSpan ts = DateTime.Now.Subtract(lastDownEvent.Created);
lastDownEvent.Value = Convert.ToInt32(ts.TotalMinutes);
Facade.EventDomainController.UpdateEvent(lastDownEvent);
}
else
{
CreateServerDownEvent(sdvm);
}
}
else
{ //just update the value
Model.Event lastUpEvent = Facade.EventDomainController.GetLatestServerUpEvent();
if (lastUpEvent != null)
{
UpdateValueAndUptime(sdvm, lastUpEvent);
}
else
{
CreateServerUpEvent(sdvm);
}
}
}
sdvm.CurrentStatus = ServerStatus;
}
catch (Exception e)
{
log.Error("ServerLogic - GetServerData: " + e);
}
return(sdvm);
}
/// <summary>
/// Updates an event
/// </summary>
/// <returns>Task</returns>
/// <param name="event">The event which replaces the old event</param>
public async Task UpdateEvent(Event @event, Guid uid)
{
await _client.Cypher
.Match("(user:User)-[:HOSTING]->(e:Event)")
.Where((Event e) => e.Id == @event.Id)
.AndWhere((User user) => user.Id == uid)
.Set("e = {newinfo}")
.WithParam("newinfo", @event)
.ExecuteWithoutResultsAsync();
}
/// <summary>
/// Add an event to the database
/// </summary>
/// <returns>Task</returns>
/// <param name="event">The event that should be added</param>
public async Task AddEvent (Event e)
{
e.Id = Guid.NewGuid();
await _client.Cypher
.Match ("(user:User)")
.Where((User user) => user.Id == e.UserId)
//creates a relation "HOSTING" between the created event
.Create ("(user)-[:HOSTING]->(event:Event {data})")
.WithParam ("data", e)
.ExecuteWithoutResultsAsync ();
}
public async Task<IHttpActionResult> Put(Event e)
{
await DB.UpdateEvent(e, UserId);
return Ok();
}
public HttpResponseMessage PostServerDetailCurrent(ServerDetailModel serverDetails)
{
try
{
if (serverDetails == null || serverDetails.ServerName == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
//Server regonized?
Server s = Facade.ServerDomainController.GetServerByName(serverDetails.ServerName);
if (s == null)
{
s = new Server();
s.Name = serverDetails.ServerName;
s = Facade.ServerDomainController.CreateServer(s);
}
//Create everytime!
ServerDetailCurrent currentServerDetail = new ServerDetailCurrent();
currentServerDetail.Handles = serverDetails.Handles;
currentServerDetail.Utilization = serverDetails.Utilization;
currentServerDetail.Thread = serverDetails.Thread;
currentServerDetail.Processes = serverDetails.Processes;
currentServerDetail.UpTime = serverDetails.Uptime;
currentServerDetail.RAMUtilization = serverDetails.RAMUtilization;
currentServerDetail.RAMAvailable = serverDetails.RAMAvailable;
currentServerDetail.RAMTotal = serverDetails.RAMTotal;
currentServerDetail.BytesReceived = serverDetails.BytesReceived;
currentServerDetail.BytesSent = serverDetails.BytesSent;
currentServerDetail.NetworkUtilization = serverDetails.NetworkUtilization;
currentServerDetail.ServerId = s.Id;
Facade.ServerDetailCurrentDomainController.CreateServerDetailCurrent(currentServerDetail);
//Styrer den sidste del af grafen (Bliver slettet løbende)
//ServerSummary hvert interval!
//der gemmes et summary hvert interval (10 MIN). DVS 13:35, består af data fra 13:30-13:40
//ved 13:30, kan vi gemme (summary 13:45)
//ved 13:40, kan vi gemme (summary 13:35) OSV
//KL 13:50:01, tjekker vi 15minutter tilbage (1,5 interval)
//Get the interval
int serverInterval = Facade.SettingDomainController.GetValueByName(StaticStrings.ServerDetailInterval);
//If interval = 10min -> check 15min back
ServerDetail latestServerDetailSummary = Facade.ServerDetailDomainController.GetLatestServerDetailByInterval(serverInterval + (serverInterval / 2));
//If null, create new
if (latestServerDetailSummary == null)
{
//get all servercurrent
List <ServerDetailCurrent> currentServerDetailsList = Facade.ServerDetailCurrentDomainController.GetAll();
//create new serverdetailSummary with the averages from all servercurrent
ServerDetail serverDetailSummary = new ServerDetail();
serverDetailSummary.Handles = Convert.ToInt32(currentServerDetailsList.Average(x => x.Handles));
serverDetailSummary.RAMAvailable = Convert.ToInt32(currentServerDetailsList.Average(x => x.RAMAvailable));
serverDetailSummary.RAMTotal = Convert.ToInt32(currentServerDetailsList.Average(x => x.RAMTotal));
serverDetailSummary.Thread = Convert.ToInt32(currentServerDetailsList.Average(x => x.Thread));
serverDetailSummary.Processes = Convert.ToInt32(currentServerDetailsList.Average(x => x.Processes));
serverDetailSummary.Utilization = Convert.ToInt32(currentServerDetailsList.Average(x => x.Utilization));
serverDetailSummary.ServerId = currentServerDetailsList.FirstOrDefault().ServerId;
serverDetailSummary.UpTime = currentServerDetailsList.LastOrDefault().UpTime;
serverDetailSummary.Created = GetStartOfInterval(DateTime.Now, serverInterval);
serverDetailSummary.BytesSent = currentServerDetailsList.Sum(x => x.BytesSent);
serverDetailSummary.BytesReceived = currentServerDetailsList.Sum(x => x.BytesReceived);
serverDetailSummary.NetworkUtilization = Convert.ToInt32(currentServerDetailsList.Average(x => x.NetworkUtilization));
latestServerDetailSummary = Facade.ServerDetailDomainController.Create(serverDetailSummary);
}
//Events - Could add more
RequestSummary requestSummary = Facade.RequestSummaryDomainController.GetRequestSummaryLastMinutes(serverInterval);
EventLogic ev = new EventLogic(); //Move most logic to this. Maybe make generic method for creating events?
Model.EventType cpuEventType = Facade.EventTypeDomainController.GetTypeByName(StaticStrings.CpuUsageHigh);
if (currentServerDetail.Utilization > cpuEventType.PeakValue)
{
//Notification
Notification n = Facade.NotificationDomainController.Create(new Notification());
//Event
Model.Event e = new Model.Event();
//ServerDetail -> tage nuværende snapshot, eller tage summary eller begge?
e.ServerDetailId = latestServerDetailSummary.Id; //Server summary
// requestSummary i dette tidsrum
e.RequestSummaryId = requestSummary == null ? 0 : requestSummary.Id;
e.Created = DateTime.Now;
e.EventTypeId = cpuEventType.Id;
e.NotificationId = n.Id;
e.Value = serverDetails.Utilization;
Model.Event createdEvent = Facade.EventDomainController.Create(e);
//Notify by email?
if (cpuEventType.Notify)
{
EmailManager emailManager = new EmailManager();
}
}
Model.EventType ramEventType = Facade.EventTypeDomainController.GetTypeByName(StaticStrings.LowMemory);
if (currentServerDetail.RAMAvailable < ramEventType.PeakValue)
{
//Notification
Notification n = Facade.NotificationDomainController.Create(new Notification());
//Event
Model.Event e = new Model.Event();
e.ServerDetailId = latestServerDetailSummary.Id;
e.RequestSummaryId = requestSummary == null ? 0 : requestSummary.Id;
e.Created = DateTime.Now;
e.EventTypeId = ramEventType.Id;
e.NotificationId = n.Id;
e.Value = serverDetails.RAMAvailable;
Model.Event createdEvent = Facade.EventDomainController.Create(e);
//Notify by email?
if (ramEventType.Notify)
{
EmailManager emailManager = new EmailManager();
}
}
}
catch (Exception e)
{
var response = new HttpResponseMessage(HttpStatusCode.BadRequest);
response.Content = new StringContent("Error: " + e);
return(response);
}
//Slet Dem her?
int setupInterval = Facade.SettingDomainController.GetValueByName(StaticStrings.ServerDetailInterval);
Facade.ServerDetailCurrentDomainController.DeleteAllOlderThanInterval(setupInterval);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public EventEditorViewModel(Event historicalEvent)
{
Name = historicalEvent.EventName;
Description = historicalEvent.EventDescription;
Year = historicalEvent.Year;
}
