private void btnAdd_Click(object sender, System.EventArgs e)
{
var addForm = new AddEvent(repository);
addForm.ShowDialog();
Reload();
}
public void Method2()
{
int a = 1;
int b = 2;
AddEvent?.Invoke(a, b);
}
public async Task GetEvents_ShouldReturnEventsifpresent()
{
//Arrange
AddEventResponse ObjAddEventResponse = new AddEventResponse();
Response ObjResponse = new Response();
ObjResponse.EventID = "1";
ObjResponse.EventName = "IPL";
ObjResponse.EventStatus = "Open";
ObjResponse.EventTimings = "7 PM";
ObjAddEventResponse.response.Add(ObjResponse);
ObjAddEventResponse.ResponseMessage = "Success";
AddEventResponse ObjAddEventResponse1 = new AddEventResponse();
List <AddEvent> obj = new List <AddEvent>();
AddEvent addEvent = new AddEvent();
addEvent.EventID = "1";
addEvent.EventName = "IPL";
addEvent.EventStatus = "Open";
addEvent.EventTimings = "7 PM";
obj.Add(addEvent);
_eventBookingService.Setup(x => x.GetEvents()).ReturnsAsync(ObjAddEventResponse);
//Act
var customer = await _EventBookingController.GetEvents();
//Assert
Assert.NotNull(customer);
}
public async Task GetEvents_ShouldReturnvalidmessage_ifnoeventpresent()
{
//Arrange
AddEventResponse ObjAddEventResponse = new AddEventResponse();
Response ObjResponse = new Response();
ObjAddEventResponse.ResponseMessage = "No events available";
AddEventResponse ObjAddEventResponse1 = new AddEventResponse();
List <AddEvent> obj = new List <AddEvent>();
AddEvent addEvent = new AddEvent();
_eventRepoMock.Setup(x => x.GetEventsDB()).ReturnsAsync(obj);
//Act
var customer = await _EventBookingService.GetEvents();
//Assert
Assert.Equal(ObjAddEventResponse.ResponseMessage, customer.ResponseMessage);
}
public void AddEventTest3()
{
DateTime Date;
Date = DateTime.Parse("16.02.1999 00:00:00");
EventModel model = new EventModel(Date, "TestEvent3");
AddEvent newEvent = new AddEvent();
newEvent.Add(model, connection);
var cmdText = $"SELECT * FROM EVENTS WHERE [DateOfEvent] = @dateOfEvent " +
$"AND [Event] = '{model.Event}'";
connection.Open();
OleDbCommand TestCommand = new OleDbCommand(cmdText, connection);
TestCommand.Parameters.Add(new OleDbParameter("@dateOfEvent", OleDbType.Date));
TestCommand.Parameters["@dateOfEvent"].Value = model.DateOfEvent;
if (TestCommand.ExecuteReader().HasRows)
{
connection.Close();
Assert.Pass();
}
else
{
connection.Close();
Assert.Fail("В таблице нет записи");
}
}
/// <summary>
/// Processes the message
/// </summary>
/// <param name="connectionBase">The connection base</param>
/// <param name="message">The message</param>
/// <param name="handled">Whether the message was already handled</param>
public void Process(ConnectionBase connectionBase, Message message, bool handled)
{
WorldConnection worldCon = (WorldConnection)connectionBase;
WorldPlayer player = new WorldPlayer(worldCon, message.GetString(1), message.GetInt(0));
player.Face = (FaceID)message.GetInt(2);
player.X = message.GetInt(3);
player.Y = message.GetInt(4);
player.InGodMode = message.GetBoolean(5);
player.IsModerator = message.GetBoolean(6);
player.HasChat = message.GetBoolean(7);
player.GoldCoins = message.GetInt(8);
player.BlueCoins = message.GetInt(9);
//Message 10 will eventually be removed or changed
//No need to get purple information
player.IsFriendsWithYou = message.GetBoolean(11);
player.HasBuildersClub = message.GetBoolean(12);
if (!handled)
{
worldCon.Players.Add(player);
}
AddEvent addEvent = new AddEvent()
{
Raw = message,
Player = player
};
connectionBase.RaiseServerEvent <AddEvent>(addEvent);
}
// Contact Manegement End
// Event Management Start
private void cpb_addevent_Click(object sender, EventArgs e)
{
AddEvent addEvent = new AddEvent();
addEvent.FormClosing += new FormClosingEventHandler(this.AddEvent_FormClosing);
addEvent.ShowDialog();
}
// Display Existing Event Details:
public ActionResult Update(int EventID)
{
AddEvent viewmodel = new AddEvent();
viewmodel.HospitalCampuses = db.HospitalCampuses.ToList();
viewmodel.Event = db.Events.Find(EventID);
return(View(viewmodel));
}
private void AddButton_Click(object sender, EventArgs e)
{
if (AddSheduleText.Text != "" && AddSheduleText.Text != null && AddSheduleText.Text.Length != 0)
{
AddEvent addEvent = new AddEvent();
addEvent.Add(AddSheduleText.Text, AddSheduleDate.Value);
UpdateViews();
}
}
private void cpb_cont_addevent_Click(object sender, EventArgs e)
{
this.pnl_eventloader.BringToFront();
pnl_events.BringToFront();
AddEvent addEvent = new AddEvent();
addEvent.FormClosing += new FormClosingEventHandler(this.AddEvent_FormClosing);
addEvent.ShowDialog();
}
public void AddNewTask(object sender, RoutedEventArgs e)
{
MyFrame.BackStack.Clear();
MyFrame.Navigate(typeof(CreateOrModifyTaskPage), this, new SuppressNavigationTransitionInfo());
ShowSlideInPane();
AddEvent?.Invoke();
//CollapseSlideInPane();
}
private void Add_Event_Button_Click(object sender, RoutedEventArgs e)
{
if (!AddPlaceOpen && !AddTourOpen && !AddEventOpen)
{
AddEvent addEvent = new AddEvent(window);
addEvent.Show();
Delete_Button.IsEnabled = false;
AddEventOpen = true;
}
}
private void FixButton_Click(object sender, RoutedEventArgs e)
{
image.Source = videoPlayer.MakeScreenShot();
AddEvent.Invoke(image.Source);
int n = Convert.ToInt32(TextBox1.Text);
n++;
TextBox1.Text = n.ToString();
}
public async Task <IActionResult> CreateEvent([FromBody] AddEvent addEvent)
{
if (addEvent == null)
{
return(BadRequest());
}
Event @event = await _eventService.CreateEventAsync(User.Identity.Name, addEvent);
return(CreatedAtRoute("GetEvent", new { id = @event.Id }, @event));
}
public FantasyFighterPlayer(AddEvent events, TcpClient client)
{
this.fighter = new FighterState();
this.socket = client;
this.client = client.Client;
this.events = events;
reader = new MessageReader();
buffer = new byte[4096];
BeginReading();
}
#pragma warning disable 169
// Used via reflection
static void AddEventFrame <T, D> (AddEvent <T, D> addEvent, object obj, object dele)
{
if (obj == null)
{
throw new TargetException("Cannot add a handler to a non static event with a null target");
}
if (!(obj is T))
{
throw new TargetException("Object doesn't match target");
}
addEvent((T)obj, (D)dele);
}
public static async Task <bool> Add(IHubUserModel user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var addNewUser = false;
while (_lock)
{
Thread.Sleep(100);
}
_lock = true;
try
{
var connectedId = user.ConnectionId.First();
var findUser = _store.FirstOrDefault(i => i.Id == user.Id);
if (findUser != null)
{
findUser.ConnectionId.Add(connectedId);
}
else
{
addNewUser = true;
_store.Add(user);
}
var findId = _store_connectedIds.FirstOrDefault(i => i.ConnectionId == connectedId);
if (findId == null)
{
_store_connectedIds.Add(new HubConnectedIdModel
{
UserId = user.Id,
ConnectionId = connectedId
});
}
AddEvent?.Invoke(user);
_lock = false;
}
catch (Exception)
{
Thread.Sleep(100);
return(await Add(user).ConfigureAwait(false));
}
return(addNewUser);
}
public void Execute()
{
var ioTEvent = GetEvent();
var addIoTEventQuery = new AddEvent
{
IoTEvent = ioTEvent,
EventsRepository = _eventsRepository,
PlantsRepository = _plantsRepository
};
_mediator.Send(addIoTEventQuery);
}
public void AddEventMessageShouldAddDatabaseEntry()
{
var message = new AddEvent
{
EventId = 1,
EventName = "TestEvent",
ResourcePlacesCount = 10,
Price = 100,
Location = "TestLocation",
Start = DateTime.Parse("2018-07-15 08:00:00.0000000"),
End = DateTime.Parse("2018 -07-15 10:00:00.0000000"),
LecturerName = "TestName",
ResourceName = "TestResource",
AdditionalInfo = "TestInfo"
};
this.newEventHandler.DbContext =
Startup.ServiceProvider.GetService(typeof(RegistrationDbContext)) as RegistrationDbContext;
NServiceBus.Testing.Test.Handler(this.newEventHandler).OnMessage(message);
var getEvents = new HttpRequestMessage(HttpMethod.Get, "api/Event");
var getEventsResponse = this.Client.SendAsync(getEvents).GetAwaiter().GetResult();
var content = getEventsResponse.Content.ReadAsStringAsync().GetAwaiter().GetResult();
//JObject getAvailableSettingsJson = JObject.Parse(content);
var apiResult = JsonConvert.DeserializeObject <List <Event> >(content);
Assert.AreEqual(apiResult.Count(), 1);
var check = apiResult.First();
Assert.AreEqual(check.EventId, message.EventId);
Assert.AreEqual(check.EventName, message.EventName);
Assert.AreEqual(check.ResourcePlacesCount, message.ResourcePlacesCount);
Assert.AreEqual(check.Price, message.Price);
Assert.AreEqual(check.Location, message.Location);
Assert.AreEqual(check.Start, message.Start);
Assert.AreEqual(check.End, message.End);
Assert.AreEqual(check.LecturerName, message.LecturerName);
Assert.AreEqual(check.ResourceName, message.ResourceName);
Assert.AreEqual(check.AdditionalInfo, message.AdditionalInfo);
var getEventDetails = new HttpRequestMessage(HttpMethod.Get, "api/Event/1");
var getEventDetailsResponse = this.Client.SendAsync(getEventDetails).GetAwaiter().GetResult();
var contentDetails = JsonConvert.DeserializeObject <Event>(getEventDetailsResponse.Content.ReadAsStringAsync().GetAwaiter().GetResult());
Assert.IsNotNull(contentDetails);
var getEventDetailsNotFound = new HttpRequestMessage(HttpMethod.Get, "api/Event/100");
var getEventDetailsNotFoundResponse = this.Client.SendAsync(getEventDetailsNotFound).GetAwaiter().GetResult();
Assert.AreEqual(getEventDetailsNotFoundResponse.StatusCode, HttpStatusCode.NotFound);
}
private void btnAdd_Click(object sender, RoutedEventArgs e)
{
if (AddEvent != null)
{
bool?result = AddEvent.Invoke();
if (result != null && result.Value)
{
if (RefreshEvent != null)
{
RefreshEvent.Invoke();
}
}
}
}
private void Insert(Node <T> node)
{
if (node is null)
{
throw new TreeException("Node can't be null", new ArgumentNullException());
}
Count++;
AddEvent?.Invoke(node.Value);
var currentNode = Root;
while (!currentNode.AddChild(node))
{
currentNode = currentNode > node ? currentNode.Left : currentNode.Right;
}
}
#pragma warning disable 169
// Used via reflection
static void AddEventFrame <T, D> (AddEvent <T, D> addEvent, object obj, object dele)
{
if (obj == null)
{
throw new TargetException("Cannot add a handler to a non static event with a null target");
}
if (!(obj is T))
{
throw new TargetException("Object doesn't match target");
}
if (!(dele is D))
{
throw new ArgumentException($"Object of type {dele.GetType ()} cannot be converted to type {typeof (D)}.");
}
addEvent((T)obj, (D)dele);
}
public IActionResult CreateEvent(AddEvent addEvent)
{
if (ModelState.IsValid)
{
Events newEvent = new Events()
{
SiteCode = addEvent.SiteCode,
Date = addEvent.Date,
Spaces = addEvent.Spaces
};
_Context.Events.Add(newEvent);
_Context.SaveChanges();
return(RedirectToAction("Events", "Home"));
}
return(View());
}
public Event Add(AddEvent model)
{
var entity = new Event
{
Id = Guid.NewGuid(),
Date = model?.Date ?? new DateTime(),
Description = model?.Description,
Name = model?.Name,
Type = model?.Type,
CreatedBy = _user
};
events.Add(entity);
return(entity);
}
public void Add(long position, byte[] bytes)
{
if (bytes == null)
{
throw new ArgumentNullException(nameof(bytes));
}
if (position < 0)
{
throw new ArgumentOutOfRangeException(nameof(position));
}
lock (_parts)
{
_parts.Add(position, bytes);
AddEvent?.Invoke(this, EventArgs.Empty);
}
}
public void Setup()
{
connection.Open();
OleDbCommand TruncateCommand = new OleDbCommand("DELETE FROM Events", connection);
TruncateCommand.ExecuteNonQuery();
connection.Close();
AddEvent @event = new AddEvent();
EventModel model;
DateTime date = DateTime.Today;
for (int Item = 0; Item < 100; Item++)
{
model = new EventModel(date, $"TestEvent № {Item}");
@event.Add(model, connection);
}
}
public LookupListProcessor(
Expression <Func <TModelData, IList <TPropData> > > listDataExpression,
Expression <Func <TModel, IList <TProp> > > listModelExpression,
Expression <Func <TPropData, TEnum> > itemDataEnumExpression,
Expression <Func <TProp, TEnum> > itemModelEnumExpression,
DeleteEvent delete,
AddEvent add
)
{
_compiledListDataExpression = listDataExpression.Compile();
_compiledListModelExpression = listModelExpression.Compile();
_compiledItemDataEnumExpression = itemDataEnumExpression.Compile();
_propertyName = typeof(TProp).Name;
_compiledItemModelEnumExpression = itemModelEnumExpression.Compile();
_add = add;
_delete = delete;
}
public async Task <Event> CreateEventAsync(string userId, AddEvent addEvent)
{
string eventId = GetNextId(_apiContext.Events.Select(e => e.Id));
Event @event = new Event
{
Id = eventId,
UserId = userId,
Description = addEvent.Description,
Date = addEvent.Date
};
await _apiContext.Events.AddAsync(@event);
await _apiContext.SaveChangesAsync();
return(await GetEventAsync(userId, eventId));
}
private void Add_Click(object sender, EventArgs e)
{
try
{
price = double.Parse(richTextBox3.Text);
info = richTextBox2.Text;
chance = double.Parse(richTextBox1.Text);
AddEvent?.Invoke(this, null);
ChangeEvent?.Invoke(this, null);
AddSquare?.Invoke(this, null);
AddTriangle?.Invoke(this, null);
Close();
}
catch
{
MessageBox.Show("Введите корректные данные");
}
}
public async Task GetEvents_ShouldReturnEventsifpresent()
{
//Arrange
AddEventResponse ObjAddEventResponse = new AddEventResponse();
Response ObjResponse = new Response();
ObjResponse.EventID = "1";
ObjResponse.EventName = "IPL";
ObjResponse.EventStatus = "Open";
ObjResponse.EventTimings = "7 PM";
ObjAddEventResponse.response.Add(ObjResponse);
ObjAddEventResponse.ResponseMessage = "Success";
AddEventResponse ObjAddEventResponse1 = new AddEventResponse();
List <AddEvent> obj = new List <AddEvent>();
AddEvent addEvent = new AddEvent();
addEvent.EventID = "1";
addEvent.EventName = "IPL";
addEvent.EventStatus = "Open";
addEvent.EventTimings = "7 PM";
obj.Add(addEvent);
_eventRepoMock.Setup(x => x.GetEventsDB()).ReturnsAsync(obj);
//Act
var customer = await _EventBookingService.GetEvents();
//Assert
Assert.Equal(ObjAddEventResponse.ResponseMessage, customer.ResponseMessage);
for (int i = 0; i < customer.response.Count; i++)
{
Assert.Equal(ObjAddEventResponse.response[i].EventID, customer.response[i].EventID);
Assert.Equal(ObjAddEventResponse.response[i].EventName, customer.response[i].EventName);
Assert.Equal(ObjAddEventResponse.response[i].EventStatus, customer.response[i].EventStatus);
Assert.Equal(ObjAddEventResponse.response[i].EventTimings, customer.response[i].EventTimings);
}
}
public void Post(AddEvent request)
{
try
{
if (calendarRepository.ContainsKey(request.CalendarId))
{
if (!eventRepository.ContainsKey(request.Event.Id))
{
var calendar = calendarRepository.Find(request.CalendarId);
calendar.Events.MergeRange(request.Event.ToSingleton());
calendarRepository.Save(calendar);
var cacheKey = keyBuilder.Build(request, x => x.Event.Id).ToString();
RequestContext.RemoveFromCache(Cache, cacheKey);
}
}
}
catch (InvalidOperationException ex)
{
logger.Error(ex.ToString());
throw;
}
catch (ApplicationException ex)
{
logger.Error(ex.ToString());
throw;
}
catch (Exception ex)
{
logger.Error(ex.ToString());
throw;
}
}
