public async Task <ActionResult <EventView> > Create(NewEvent eventItem, ApiVersion apiVersion)
{
var result = dataBaseContext.Events.Add(eventItem.ToEvent());
await dataBaseContext.SaveChangesAsync();
return(CreatedAtAction(nameof(GetById), new { id = result.Entity.Id, version = apiVersion.ToString() }, eventItem));
}
private async Task Process(MyType e, StreamSequenceToken sequenceToken)
{
// Console.WriteLine($"Filter Grain receives: {e.key}, {e.value}, {e.timestamp.GetTimestamp()}");
bool emit_e;
MyType ee;
if (e.value == "watermark")
{
ee = e;
emit_e = true;
}
else
{
string Key = await jobManager.GetKey(this.GetPrimaryKey());
string Value = await jobManager.GetValue(this.GetPrimaryKey());
ee = NewEvent.CreateNewEvent(e, Key, Value);
emit_e = Apply(ee);
}
List <Task> t = new List <Task>();
if (emit_e) // If the function returns true, send the element to SinkGrain
{
List <Guid> streams = await jobManager.GetPublish(this.GetPrimaryKey());
foreach (var item in streams)
{
var stream = streamProvider.GetStream <MyType>(item, null);
t.Add(stream.OnNextAsync(ee));
}
}
await Task.WhenAll(t);
}
public void OnContainerClick()
{
if (DragDropHelper.Items.FindAll(x => x.Event.Start == Start).Count == 0)
{
NewEvent?.Invoke(Start);
}
}
public async Task Process(MyType e, StreamSequenceToken sequenceToken) // Implements the Process method from IFilter
{
List <MyType> result = new List <MyType>();
if (e.value == "watermark")
{
result.Add(e);
}
else
{
string Key = await jobManager.GetKey(this.GetPrimaryKey());
string Value = await jobManager.GetValue(this.GetPrimaryKey());
MyType new_e = NewEvent.CreateNewEvent(e, Key, Value);
result = Apply(new_e);
}
List <Task> t = new List <Task>();
List <Guid> streams = await jobManager.GetPublish(this.GetPrimaryKey());
foreach (var item1 in streams)
{
var stream = streamProvider.GetStream <MyType>(item1, null);
foreach (var item2 in result)
{
t.Add(stream.OnNextAsync(item2));
}
}
await Task.WhenAll(t);
}
public void AddEvent(NewEvent newEvent)
{
Throw.IfNull(newEvent, nameof(newEvent));
_logger.Debug($"{nameof(AddEvent)} has been called with event with title {newEvent.Title}.");
using (new Sitecore.SecurityModel.SecurityDisabler())
{
Item parent = GetRandomEventList();
Item newEventItem = parent.Add($"{newEvent.Title} n{_random.Next()}", _eventTemplateId);
newEventItem.Editing.BeginEdit();
try
{
newEventItem.Fields[EventDetailsPage.Fields.Description].Value = newEvent.Description;
newEventItem.Fields[EventDetailsPage.Fields.ButtonText].Value = newEvent.ButtonText;
newEventItem.Fields[EventDetailsPage.Fields.Difficulty].Value = $"{newEvent.Difficulty}";
newEventItem.Fields[EventDetailsPage.Fields.StartDate].Value = DateUtil.ToIsoDate(newEvent.StartDate);
newEventItem.Fields[EventDetailsPage.Fields.EndDate].Value = DateUtil.ToIsoDate(newEvent.EndDate);
newEventItem.Fields[EventDetailsPage.Fields.Title].Value = newEvent.Title;
newEventItem.Fields[EventDetailsPage.Fields.ShortDescription].Value = newEvent.ShortDescription;
newEventItem.Editing.EndEdit();
}
catch (Exception exception)
{
_logger.Error(exception.Message);
newEventItem.Editing.CancelEdit();
}
}
}
public void FilterEvent_TimeMatch_After()
{
_context.Database.EnsureDeleted();
var e1 = new NewEvent()
{
On = "2001/01/01 01:01",
Type = "MyEventType1",
Entities = new [] { "E1" }
};
var e2 = new NewEvent()
{
On = "2001/01/01 01:02",
Type = "MyEventType2",
Entities = new [] { "E1" }
};
_service.RegisterEvent(e1);
_service.RegisterEvent(e2);
var match = _service.SearchEvents(new string[] { "On>2001/01/01 01:01" });
Assert.Single(match);
Assert.Equal("MyEventType2", match.First().Type);
}
public void ClusterFilter_LessThanOrEqual_Within_Filter()
{
_context.Database.EnsureDeleted();
var e1 = new NewEvent()
{
On = "2001/01/01 01:01",
Type = "MyEventType1",
Entities = new[] { "E1" }
};
var e2 = new NewEvent()
{
On = "2001/01/01 01:06",
Type = "MyEventType1",
Entities = new[] { "E1" }
};
_service.RegisterEvent(e1);
_service.RegisterEvent(e2);
var match = _service.ClusterEvents(
new string[] { "On > 2001/01/01 01:00" },
new string[] { "Within <= 0.0:5:0" });
Assert.Single(match);
Assert.Equal(new DateTime(2001, 1, 1, 1, 1, 0).ToString("yyyy-MM-ddTHH\\:mm\\:ss.fffffffzzz"), match.First().Start);
Assert.Equal(new DateTime(2001, 1, 1, 1, 6, 0).ToString("yyyy-MM-ddTHH\\:mm\\:ss.fffffffzzz"), match.First().End);
}
public void FilterEvent_BasicStateMatch_OutOfOrder()
{
_context.Database.EnsureDeleted();
var e1 = new NewEvent()
{
On = "2001/01/01 01:01",
Type = "MyEventType",
Entities = new string[] { "E1" }
};
var o1 = new Observation()
{
On = "2001/01/01 01:01",
Type = "MyObservationType",
Entity = "E1",
Expressions = new string[] { "State.MyVal=Hello World" }
};
_service.RegisterEvent(e1);
_service.RegisterObservation(o1);
var match = _service.SearchEvents(new string[] { "State.MyVal=Hello World" });
var nonMatch = _service.SearchEvents(new string[] { "State.MyVal=Not The One!" });
Assert.Single(match);
Assert.Empty(nonMatch);
}
public IActionResult add_event(NewEvent activity)
{
if (ModelState.IsValid)
{
int?currUserId = HttpContext.Session.GetInt32("UserId");
if (currUserId == null)
{
ModelState.AddModelError("Title", "Please log in to add event");
return(View("new_event", activity));
}
DateTime dtNow = DateTime.Now.ToUniversalTime();
DateTime dtEvent = activity.newActivity.EventDateTime.Date + activity.time.TimeOfDay;
if (DateTime.Compare(dtNow, dtEvent.ToUniversalTime()) > 0)
{
ModelState.AddModelError("time", "Activity must be in the future");
return(View("new_event", activity));
}
activity.newActivity.CreatorId = (int)currUserId;
activity.newActivity.EventDateTime = dtEvent;
dbContext.Events.Add(activity.newActivity);
dbContext.SaveChanges();
return(Redirect("dashboard"));
}
else
{
return(View("new_event", activity));
}
}
private void EnsureBlockSubscribed()
{
if (_eventsSubscription != null)
{
return;
}
this.MakeCallWithReconnect(app =>
{
var storageKey = app.GetKeys("System", "Events");
_eventsSubscription = app.SubscribeStorage(storageKey, change =>
{
if (change == null)
{
return;
}
try
{
var events = GetApplication().Serializer
.DeserializeAssertReadAll <EventList>(change.HexToByteArray()).Events;
foreach (var eventRecord in events)
{
NewEvent?.Invoke(this, eventRecord.Event);
}
}
catch (Exception ex)
{
Settings.Logger.Error($"Failed to deserialize events: {ex}");
OnError?.Invoke(this, ex);
throw;
}
});
}, Settings.MaxReconnectCount);
}
/// <summary>HTML.</summary>
/// <returns>Строка.</returns>
public ObservableCollection <NewEvent> GetNews()
{
var news = new ObservableCollection <NewEvent>();
var newsData = new NewsData();
var newsList = newsData.GetNews(this.employeeLst);
var newsT = newsList.News;
if (newsT != null && newsT.Count != 0)
{
foreach (var n in newsT.OrderBy(a => a.Date))
{
news.Add(n);
}
}
else
{
var newT = new NewEvent
{
Prefix = "На данный момент количество новостей ",
Postfix = " штук"
};
news.Add(newT);
}
return(news);
}
public IHttpActionResult AddEvent(HttpRequestMessage requestMessage, NewEvent newEvent)
{
var @event = _addEventMaintenanceProcessor.AddEvent(newEvent);
var result = new EventCreatedActionResult(requestMessage, @event);
return result;
}
public void GenerateEvent_ShouldCallProperMethodsAndReturnCorrectResult()
{
var expectedEvent = new NewEvent
{
Description = "d",
ShortDescription = "sd",
ButtonText = "bt",
Title = "t"
};
_eventSourceReader
.Setup(x => x.ReadSourceSectionValue(EventDetailsPage.Fields.ButtonText_FieldName))
.Returns(expectedEvent.ButtonText);
_eventSourceReader
.Setup(x => x.ReadSourceSectionValue(EventDetailsPage.Fields.Description_FieldName))
.Returns(expectedEvent.Description);
_eventSourceReader
.Setup(x => x.ReadSourceSectionValue(EventDetailsPage.Fields.ShortDescription_FieldName))
.Returns(expectedEvent.ShortDescription);
_eventSourceReader
.Setup(x => x.ReadSourceSectionValue(EventDetailsPage.Fields.Title_FieldName))
.Returns(expectedEvent.Title);
var result = _randomEventService.GenerateNewEvent();
Assert.Equal(expectedEvent.Title, result.Title);
Assert.Equal(expectedEvent.ShortDescription, result.ShortDescription);
Assert.Equal(expectedEvent.Description, result.Description);
Assert.Equal(expectedEvent.ButtonText, result.ButtonText);
}
private async Task GetEventsAsync()
{
using (ClientWebSocket ws = new ClientWebSocket())
{
string url = API.BaseUrl.AbsoluteUri.Replace("http", "ws") + $"{Version}/events";
await ws.ConnectAsync(new Uri(url), CancellationToken.None);
while (ws.State == WebSocketState.Open)
{
StringBuilder msg = new StringBuilder();
byte[] buffer = new byte[1024];
WebSocketReceiveResult receiveResult;
do
{
receiveResult = await ws.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
msg.Append(Encoding.UTF8.GetString(buffer, 0, receiveResult.Count));
} while (!receiveResult.EndOfMessage);
Console.WriteLine(msg);
// NewEvent?.Invoke(wsEvent, msg);
NewEvent?.Invoke(ws, EventArgs.Empty);
}
}
}
public IActionResult Update(int?Id)
{
ViewBag.Speakers = _db.NewManagmentBoards.ToList();
NewEvent newEvent = _db.NewEvents.Where(w => w.IsDeleted == false).Include(c => c.NewManagmentEvents).ThenInclude(v => v.NewManagmentBoard).FirstOrDefault(f => f.Id == Id);
return(View(newEvent));
}
private void newEvent(object obj)
{
NewEvent ne = new NewEvent();
if (ne.ShowDialog( ) == true)
{
if (ne.Event == null)
{
MessageBox.Show("An error occurred, the event was not made");
}
Championship.addEvent(ne.Event);
//SaveToDB ( );
EditEvent ee = new EditEvent();
ee.DataContext = new EventVM(ne.Event);
ee.ShowDialog( );
SaveToDB( );
RaisePropertyChanged("Events");
if (obj is EventsPage)
{
((EventsPage)obj).ReloadPage( );
}
}
else
{
return;
}
}
public void FilterEvent_EventMultiTypeMatch()
{
_context.Database.EnsureDeleted();
var e1 = new NewEvent()
{
On = "2001/01/01 01:01",
Type = "MyEventType1",
Entities = new[] { "E1" }
};
var e2 = new NewEvent()
{
On = "2001/01/01 01:01",
Type = "MyEventType2",
Entities = new[] { "E1" }
};
var e3 = new NewEvent()
{
On = "2001/01/01 01:01",
Type = "MyEventType3",
Entities = new[] { "E1" }
};
_service.RegisterEvent(e1);
_service.RegisterEvent(e2);
_service.RegisterEvent(e3);
var match = _service.SearchEvents(new string[] { "Type=[MyEventType1,MyEventType2]" });
Assert.Equal("MyEventType1", match.First().Type);
Assert.Equal("MyEventType2", match.Skip(1).First().Type);
Assert.Equal(2, match.Count());
}
/// <summary>
/// The ButtonAdd_Click method.
/// </summary>
/// <param name="sender">The <paramref name="sender"/> parameter.</param>
/// <param name="args">The <paramref name="args"/> parameter.</param>
private void ButtonAdd_Click(object sender, EventArgs args)
{
var newEvent = new NewEvent
{
GeneratorDeviceId = txbxGeneratorDeviceId.Text,
SituationType = cbxSituationType.Text,
SourceDeviceId = cbxSourceDeviceId.Text,
Time = dtpTime.Value.ToUniversalTime()
};
// Check each property text box to see if there is a value. If so, add it to the new event.
var propertyList = new List <KeyValuePair <string, string> >();
if (!string.IsNullOrEmpty(txbxName1.Text) && !string.IsNullOrEmpty(txbxValue1.Text))
{
propertyList.Add(new KeyValuePair <string, string>(txbxName1.Text, txbxValue1.Text));
}
if (!string.IsNullOrEmpty(txbxName2.Text) && !string.IsNullOrEmpty(txbxValue2.Text))
{
propertyList.Add(new KeyValuePair <string, string>(txbxName2.Text, txbxValue2.Text));
}
if (!string.IsNullOrEmpty(txbxName3.Text) && !string.IsNullOrEmpty(txbxValue3.Text))
{
propertyList.Add(new KeyValuePair <string, string>(txbxName3.Text, txbxValue3.Text));
}
newEvent.Properties = propertyList;
MainForm.CurrentSystem.InjectEvent(newEvent);
}
public async Task RunAsync(CancellationToken cancellationToken)
{
var externalTemperatureDevice = new ExternalTemperatureDevice(_droneId);
var internalTemperatureDevice = new InternalTemperatureDevice(
_droneId,
_snapInternalTemperatureLikelihood);
var gpsDevice = new GpsDevice(_droneId, GetCurrentLocation);
var devices = new Device[]
{
externalTemperatureDevice,
internalTemperatureDevice,
gpsDevice
};
foreach (var d in devices)
{ // Bubble up
d.NewEvent +=
(sender, eventData) => NewEvent?.Invoke(sender, eventData);
}
var deviceTasks = from d in devices
select d.RunAsync(cancellationToken);
var moveTask = MoveAsync(cancellationToken);
await Task.WhenAll(deviceTasks.Prepend(moveTask));
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="timeProvider">The time provider to use</param>
public RealTimeScheduleEventService(ITimeProvider timeProvider)
{
_nextUtcScheduledEvent = Ref.Create(new ReferenceWrapper <DateTime>(DateTime.MinValue));
_timer = new Timer(
async state =>
{
var nextUtcScheduledEvent = ((Ref <ReferenceWrapper <DateTime> >)state).Value.Value;
var diff = nextUtcScheduledEvent - timeProvider.GetUtcNow();
// we need to guarantee we trigger the event after the requested due time
// has past, if we got called earlier lets wait until time is right
while (diff.Ticks > 0)
{
if (diff.Milliseconds >= 1)
{
Thread.Sleep(diff);
}
else
{
Thread.SpinWait(1000);
}
// testing has shown that it sometimes requires more than one loop
diff = nextUtcScheduledEvent - timeProvider.GetUtcNow();
}
NewEvent?.Invoke(this, EventArgs.Empty);
},
_nextUtcScheduledEvent,
// Due time is never, has to be scheduled
Timeout.InfiniteTimeSpan,
// Do not trigger periodically
Timeout.InfiniteTimeSpan);
}
public void RegisterEvent(NewEvent e)
{
if (e.Entities == null)
{
throw new Exception("You must specify entities");
}
_context.Events.Add(new Provider.EntityFramework.DataModels.Event()
{
EntityList = String.Join(",", e.Entities),
On = DateTime.Parse(e.On),
Type = e.Type
});
if (_context.EventTypes.Count(x => x.Type == e.Type) == 0)
{
_context.EventTypes.Add(new DataModels.EventType()
{
Type = e.Type
});
}
_context.SaveChanges();
foreach (var agent in _eventAgents)
{
foreach (var entity in e.Entities)
{
//agent.OnNewEvent(entity, e.Type, DateTime.Parse(e.On));
}
}
}
public async Task <bool> CreateEvent(NewEvent newEvent)
{
bool isExists = await IsEventExists(newEvent.EventName);
if (isExists)
{
return(false);
}
Event newModel = new Event(newEvent);
try
{
// newModel.EventType =await _context.EventTypes.FirstOrDefaultAsync(x => x.Id == newModel.EventTypeId);
//newModel.EventUser =await _context.User.FirstOrDefaultAsync(x => x.Id == newModel.EventUserId);
// newModel.EventParticipants = new ICollection<Participant>();
newModel.EventParticipants.Add(new Participant()
{
EventId = newModel.Id, isAdmin = true, UserId = newModel.EventUserId
});
_context.Events.Add(newModel);
await _context.SaveChangesAsync();
}
catch (Exception ec)
{
var s = ec;
}
return(true);
}
public IActionResult PostEvent([FromBody] NewEvent newEvent)
{
var authenticatedUser = GetAuthenticatedUserNetname();
_eventRepo.InsertEvent(newEvent, authenticatedUser); //default user for now until everything is tested
return(Ok());
}
private void newEventButton_Click(object sender, EventArgs e)
{
if (personListBox.SelectedItem != null)
{
NewEvent test = new NewEvent(((Address)addressListBox.SelectedItem).name, ((Person)personListBox.SelectedItem).ToString());
test.Owner = this;
test.Show();
}
}
public void GetEvent(BllEvent Event)
{
UiEvent newEvent = new NewEvent(Event, "");
AddNewEvent(newEvent);
SerializeEvents();
Signal.PlaySignalAccordingToEventConfigValue();
SortEventsUsingLastOrderFromCache();
}
private async Task Process(MyType e, StreamSequenceToken sequenceToken)
{
List <Guid> streams = await jobManager.GetPublish(this.GetPrimaryKey());
List <Task> t = new List <Task>();
Console.WriteLine($"AggregateGrain receives:{e.key}, {e.value}, {e.timestamp.GetTimestamp()}");
MyType ee;
if (e.value == "watermark")
{
ee = e;
}
else
{
string Key = await jobManager.GetKey(this.GetPrimaryKey());
string Value = await jobManager.GetValue(this.GetPrimaryKey());
ee = NewEvent.CreateNewEvent(e, Key, Value);
}
var r = func.FeedData(ee); // r could be an empty dictionary
if (r.Count > 0)
{
foreach (KeyValuePair <long, List <MyType> > records in r)
{
MyType watermark = new MyType("", "watermark", new Timestamp(records.Key));
List <MyType> result = Apply(records.Value);
foreach (var item in streams)
{
var stream = streamProvider.GetStream <MyType>(item, null);
foreach (var record in result)
{
t.Add(stream.OnNextAsync(record));
}
}
await Task.WhenAll(t);
t = new List <Task>();
foreach (var item in streams)
{
var stream = streamProvider.GetStream <MyType>(item, null);
t.Add(stream.OnNextAsync(watermark));
}
await Task.WhenAll(t);
}
await Task.WhenAll(t);
}
else
{
await Task.CompletedTask;
}
}
public void ClusterFilter_LayeredCluster2()
{
_context.Database.EnsureDeleted();
var e1 = new NewEvent()
{
On = "2001/01/01 01:01",
Type = "MyEventType1",
Entities = new[] { "E1" }
};
var e2 = new NewEvent()
{
On = "2001/01/01 01:02",
Type = "MyEventType2",
Entities = new[] { "E1" }
};
var e3 = new NewEvent()
{
On = "2001/01/01 01:03",
Type = "MyEventType3",
Entities = new[] { "E1" }
};
var e4 = new NewEvent()
{
On = "2001/01/01 01:04",
Type = "MyEventType4",
Entities = new[] { "E1" }
};
var e5 = new NewEvent()
{
On = "2001/01/01 01:05",
Type = "MyEventType4",
Entities = new[] { "E1" }
};
_service.RegisterEvent(e2);
_service.RegisterEvent(e1);
_service.RegisterEvent(e3);
_service.RegisterEvent(e4);
_service.RegisterEvent(e5);
var match = _service.ClusterEvents(
new string[] { "On > 2001/01/01 01:00" },
new string[] {
" 1 | MyCluster1 | Sequence = [MyEventType1,MyEventType2]",
" 1 | MyCluster2 | Sequence = [MyEventType3,MyEventType4]",
" 2 | FinalCluster | Within <= 0.0:01:00"
});
Assert.Equal("FinalCluster", match.First().Type);
Assert.Single(match);
}
private void Append(string name, DateTime date, byte[] data, long expectedVersion)
{
var @event = DesserializeEvent(data);
@event.Version = expectedVersion;
@event.Date = date;
NewEvent?.Invoke(@event);
}
public async Task <IActionResult> AddEvent(NewEvent model)
{
bool isAdded = await _eventService.CreateEvent(model);
if (isAdded)
{
return(Ok(new { Status = "OK", Message = "Poprawnie dodano Event!" }));
}
return(Ok(new { Status = "Exists", Message = "Taki Event już istnieje!" }));
}
public void SerializeEvent_ShouldSerializeEventToProperString()
{
var objectParameter = new NewEvent {
ButtonText = "bt"
};
var expectedString = "{\"Title\":null,\"StartDate\":\"0001-01-01T00:00:00\",\"EndDate\":\"0001-01-01T00:00:00\",\"Description\":null,\"ShortDescription\":null,\"Difficulty\":0,\"ButtonText\":\"bt\"}";
var result = _serializingService.SerializeEvent(objectParameter);
Assert.Equal(expectedString, result);
}
public ActionResult New(NewEvent form)
{
return Handle(form, RedirectToAction("New"));
}
public TransactionWrite(long transactionId, NewEvent[] events, bool requireMaster)
{
TransactionId = transactionId;
Events = events;
RequireMaster = requireMaster;
}
public WriteEvents(string eventStreamId, int expectedVersion, NewEvent[] events, bool requireMaster)
{
EventStreamId = eventStreamId;
ExpectedVersion = expectedVersion;
Events = events;
RequireMaster = requireMaster;
}
public TransactionWrite(long transactionId, NewEvent[] events, bool allowForwarding)
{
TransactionId = transactionId;
Events = events;
AllowForwarding = allowForwarding;
}
public WriteEvents(string eventStreamId, int expectedVersion, NewEvent[] events, bool allowForwarding)
{
EventStreamId = eventStreamId;
ExpectedVersion = expectedVersion;
Events = events;
AllowForwarding = allowForwarding;
}
private static extern Int32 init(ServerMode serverMode, string IP, int port, NewEvent newEvent, NewIntegerValue newIntegerValue, NewDoubleValue newDoubleValue, NewStringValue newStringValue, IntPtr param);
private void Form1_Load(object sender, EventArgs e)
{
comboBox1.SelectedIndex = 0;
comboBox2.SelectedIndex = 0;
comboBox3.SelectedIndex = 0;
comboBox4.SelectedIndex = 0;
comboBox5.SelectedIndex = 0;
NewEventDelegate = new NewEvent(newEvent);
NewIntegerValueDelegate = new NewIntegerValue(newIntegerValue);
NewDoubleValueDelegate = new NewDoubleValue(newDoubleValue);
NewStringValueDelegate = new NewStringValue(newStringValue);
}
public object Get(NewEvent request)
{
return new ServiceResult<EventDescription>
{
Success = true,
Result = _eventManager.New(),
Errors = new string[] { }
};
}
