public void Consume(ReportMessageEvent @event)
{
_distributor.NotifyAdmins(new ReportMessageNotification(@event.SenderName, @event.SuspectedName,
@event.Reason, @event.Description));
_eventRepository.AddEvent(new Event(@event));
}
public int addEvent(Event e, int adminId)
{
e.AvailableSeats = e.TotalSeats;
e.PendingRequests = 0;
e.EventAdminId = adminId;
return(_IEventRepository.AddEvent(e));
}
public async Task <ActionResult <EventViewDto> > CreateEvent([FromBody] EventInputDto eventInputDto)
{
if (eventInputDto == null)
{
return(BadRequest());
}
//model state validation is not required due to the [ApiController] attribute automatically returning UnprocessableEntity (see startup.cs)
//when model binding fails
//fetch the user id from the JWT via HttpContext. Then get the user from the repository. This is to ensure that an authorized user
//is calling the API with a valid user id
var user = await _userRepository.GetUserAsync(User.GetUserId());
if (user == null)
{
return(BadRequest(new { Error = "The user was not found in the system. Please try again with an authorized and valid user." }));
}
var eventToAdd = _mapper.Map <Event>(eventInputDto); //map EventInputDto to Event
eventToAdd.UserId = user.Id; //set the user id as otherwise navigation property will be null
_eventRepository.AddEvent(eventToAdd);
if (!await _eventRepository.SaveChangesAsync())
{
throw new Exception($"Error saving Event {eventToAdd.Id} to the database");
}
var eventToReturn = _mapper.Map <EventViewDto>(eventToAdd);
return(CreatedAtRoute("GetEvent", new { id = eventToAdd.Id }, eventToReturn));
}
/// <inheritdoc />
public async Task <Unit> Handle(AddEventCommand request, CancellationToken cancellationToken)
{
_eventRepository.AddEvent(request.TheEvent);
await _eventRepository.SaveChanges();
return(Unit.Value);
}
public async Task <Event> PostEvent(Event @event)
{
//@event.Start = StringToDateTime(@event.StartString);
//@event.End = StringToDateTime(@event.EndString);
return(await _eventRepos.AddEvent(@event));
}
public async Task <ActionResult <BasketLine> > Post(Guid basketId,
[FromBody] BasketLineForCreation basketLineForCreation)
{
if (!await _basketRepository.BasketExists(basketId))
{
return(NotFound());
}
if (!await _eventRepository.EventExists(basketLineForCreation.EventId))
{
var eventFromCatalog = await _eventCatalogService.GetEvent(basketLineForCreation.EventId);
_eventRepository.AddEvent(eventFromCatalog);
await _eventRepository.SaveChanges();
}
var basketLineEntity = _mapper.Map <Entities.BasketLine>(basketLineForCreation);
var processedBasketLine = await _basketLinesRepository.AddOrUpdateBasketLine(basketId, basketLineEntity);
await _basketLinesRepository.SaveChanges();
var basketLineToReturn = _mapper.Map <BasketLine>(processedBasketLine);
return(CreatedAtRoute(
"GetBasketLine",
new { basketId = basketLineEntity.BasketId, basketLineId = basketLineEntity.BasketLineId },
basketLineToReturn));
}
public IActionResult CreateEvent([FromForm] EventModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.StartTime < DateTime.UtcNow.ToUserTime(User))
{
ModelState.AddModelError("StartTime", "Start Time has to be in the future!");
return(View(model));
}
var e = eventRepository.AddEvent(new Event
{
StartTime = model.StartTime.UtcFromUser(User),
EndTime = null,
Private = false,
OwnerId = User.Identity.GetUserId(),
Name = model.Name,
Description = model.Description
});
foreach (var modelInvitedUserID in model.InvitedUsers)
{
var parsed = TryParseObjectId(modelInvitedUserID);
if (parsed.HasValue)
{
invitationRepository.InviteUserToEvent(parsed.Value, User.Identity.GetUserId(), e.Id, true);
}
}
return(RedirectToAction("Index"));
}
public override void Execute()
{
Product currentProduct = _productRepository.GetProduct(ProductUpdate.Id);
if (currentProduct == null)
{
Logger.Info("Update Attempt, could not find product: {@id}", ProductUpdate.Id);
IsSuccesful = false;
return;
}
if (currentProduct.Deleted)
{
Logger.Info("Update Attempt, product is deleted: {@id}", ProductUpdate.Id);
IsSuccesful = false;
return;
}
foreach (PropertyUpdate propertyUpdate in ProductUpdate.Updates)
{
PatchProperty(propertyUpdate, currentProduct);
}
if (!IsSuccesful)
{
return;
}
currentProduct.LastUpdate = DateTime.Now;
_productRepository.UpdateProduct(currentProduct);
_eventRepository.AddEvent(currentProduct.ConstructEvent(EventType.Updated));
Logger.Info("Product updated {@id}", ProductUpdate.Id);
}
public int CreateEvent(CreateEventRequest request)
{
var errors = _eventRequestsValidator.ValidateCreateEventRequest(request);
if (errors.Count > 0)
{
throw new ValidationException();
}
var endDate = _eventDateCalculator.CalculateEventEndDate(request.StartDate, request.EndDate, request.RecurrenceType, request.Interval,
request.Duration, request.Occurences, request.FrequencyType, request.Days);
return(_eventRepository.AddEvent(new CalendarEvent
{
Duration = request.Duration,
EndDate = endDate,
IsAllDay = request.IsAllDay,
Name = request.Name,
StartDate = request.StartDate,
Days = request.Days,
FrequencyType = request.FrequencyType,
Interval = request.Interval,
RecurrenceType = request.RecurrenceType,
Occurences = request.Occurences,
}));
}
public IActionResult Add(AddViewModel model)
{
Image newImage = new Image
{
Id = Guid.NewGuid(),
FileName = model.Image.FileName,
Title = model.Image.Name
};
if (model.Image.Length > 0)
{
using (var ms = new MemoryStream())
{
model.Image.CopyTo(ms);
var fileBytes = ms.ToArray();
newImage.ImageFile = fileBytes;
}
}
model.NewEvent.Id = Guid.NewGuid();
model.NewEvent.StatusId = Guid.Parse("7ca65c86-0e39-465f-874d-fcb3c9183f1b"); // privremeno rjesenje, stavlja status na upcoming
newImage.EventId = model.NewEvent.Id;
_eventRepository.AddEvent(model.NewEvent);
_imageRepository.AddImage(newImage);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> PostEvent(Event mobEvent)
{
var user = await userRepository.GetUserByInternalId(mobEvent.CreatedByUserId).ConfigureAwait(false);
if (user == null || !ValidateUser(user.NameIdentifier))
{
return(Forbid());
}
var eventId = await eventRepository.AddEvent(mobEvent).ConfigureAwait(false);
var message = $"A new event: {mobEvent.Name} in {mobEvent.City} has been created on TrashMob.eco!";
var htmlMessage = $"A new event: {mobEvent.Name} in {mobEvent.City} has been created on TrashMob.eco!";
var subject = "New Event Alert";
var recipients = new List <EmailAddress>
{
new EmailAddress {
Name = Constants.TrashMobEmailName, Email = Constants.TrashMobEmailAddress
}
};
await emailManager.SendGenericSystemEmail(subject, message, htmlMessage, recipients, CancellationToken.None).ConfigureAwait(false);
return(CreatedAtAction(nameof(GetEvent), new { eventId }));
}
private void ThreadWriter(IEventRepository repository, List <Event> result, int threadId, string[] shards)
{
try
{
for (var i = 0; i < 1000; ++i)
{
string scopeId;
do
{
scopeId = Guid.NewGuid().ToString();
} while (!shards.Contains(CalculateShard(scopeId)));
var eventContent = GenerateEventContent();
var eventInfo = repository.AddEvent(scopeId, eventContent);
Assert.AreEqual(scopeId, eventInfo.Id.ScopeId);
result.Add(new Event
{
EventContent = eventContent,
EventInfo = eventInfo,
});
LogEventBatch("ThreadWriter" + threadId.ToString("D2"), new[] { eventInfo });
}
}
catch (Exception e)
{
Console.WriteLine("Throws exception " + e.GetType().Name + ". " + e.Message + Environment.NewLine + e.StackTrace);
throw;
}
}
private async void btnSave_Click(object sender, RoutedEventArgs e)
{
if (!CheckForProperDateUsage())
{
return;
}
try
{
if (!AddEventDatesAndTimes())
{
return; //this must be before BuildNamesForTheEvent()
}
if (!BuildNamesForTheEvent())
{
return;
}
if (membersOnlyCheck.IsChecked == true)
{
view.MembersOnly = true;
}
else
{
view.MembersOnly = false;
}
if (view.EventID == "0")
{
view.EventID = Guid.NewGuid().ToString();
view.CreatedBy = userInfo.userAccountName;
view.LastModifiedBy = userInfo.userAccountName;
eventRepository.AddEvent(view);
await NewAuditLine("Created by:" + userInfo.userAccountName + " Event:" + view.EventID + " " + view.AbrevEventname + " On Date: " + view.LastModifiedDate.ToString()
+ "To:" + view.DisplayName + " " + view.EventStart + " " + view.EventEnd + " Members Only:" + view.MembersOnly + " QuizID:" + view.QuizID);
await SaveEventItemsToThisEvent();
}
else
{
eventRepository.UpdateEvent(view);
Event newView = eventRepository.GetEvent(view.EventID);
if (startView != newView)
{
view.LastModifiedBy = userInfo.userAccountName;
view.LastModifiedDate = DateTime.Now;
eventRepository.UpdateEvent(view);
await NewAuditLine("Modified(Edit) by:" + userInfo.userAccountName + " Event:" + view.EventID + " " + view.AbrevEventname + " On Date:" + view.LastModifiedDate.ToString()
+ " To:" + view.DisplayName + " " + view.EventStart + " " + view.EventEnd + " Members Only:" + view.MembersOnly + " QuizID:" + view.QuizID);
}
await SaveEventItemsToThisEvent();
}
Frame.GoBack();
}
catch (Exception)
{
Jeeves.ShowMessage("Error", "Failed to save Event; please try again");
}
}
public async Task <EventDTO> AddEvent(AddEventDTO eventDto)
{
var eventEntity = _mapper.Map <Event>(eventDto);
var result = await _eventRepository.AddEvent(eventEntity);
return(_mapper.Map <EventDTO>(result));
}
public async Task <int> SaveEvent([FromBody] Event data)
{
int eventId = 0;
try
{
// mappper to convert to DTO objects
var eventData = _mapper.Map <Event, EventDTO>(data);
var comment = _mapper.Map <Comment, CommentDTO>(data.Comments[0]);
var attachment = new AttachmentDTO();
if (data.Attachments != null && data.Attachments.Count > 0)
{
attachment = _mapper.Map <Attachment, AttachmentDTO>(data.Attachments[0]);
}
// call repository method to save an event
eventId = await _eventRepository.AddEvent(eventData, comment, attachment);
}
catch (Exception ex)
{
using (_logger.BeginScope(new Dictionary <string, object> {
{ "Events", "Save Event" }
}))
{
_logger.LogError(ex.Message);
}
// throw ex;
}
return(eventId);
}
public IActionResult AddEvent(EventCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFilename = null;
if (model.Photo != null)
{
string uploadFolder = Path.Combine(_hostingEnvironment.WebRootPath, "images");
uniqueFilename = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadFolder, uniqueFilename);
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
ClgEvent @event = new ClgEvent
{
Title = model.Title,
Category = model.Category,
Date = model.Date,
Status = status.New,
Venue = model.Venue,
Description = model.Description,
PhotoPath = uniqueFilename
};
_eventRepository.AddEvent(@event);
return(RedirectToAction("EventDetails", new { id = @event.Id, updated = false }));
}
return(View());
}
private void ThreadWriter(IEventRepository repository, List <Event> result, int threadId)
{
try
{
var totalWrites = 0;
long totalMilliseconds = 0;
long maxMilliseconds = 0;
long bigger500ms = 0;
long bigger1000ms = 0;
for (var i = 0; i < 1000; ++i)
{
var scopeId = Guid.NewGuid().ToString();
var eventContent = GenerateEventContent();
var stopWatch = Stopwatch.StartNew();
var eventInfo = repository.AddEvent(scopeId, eventContent);
totalWrites++;
var elapsedMilliseconds = stopWatch.ElapsedMilliseconds;
totalMilliseconds += elapsedMilliseconds;
if (elapsedMilliseconds > maxMilliseconds)
{
maxMilliseconds = elapsedMilliseconds;
}
if (elapsedMilliseconds > 500)
{
bigger500ms++;
}
if (elapsedMilliseconds > 1000)
{
bigger1000ms++;
}
Assert.AreEqual(scopeId, eventInfo.Id.ScopeId);
result.Add(new Event
{
EventContent = eventContent,
EventInfo = eventInfo,
});
LogEventBatch("ThreadWriter" + threadId.ToString("D2"), new[] { eventInfo });
}
Console.WriteLine("ThreadWriter {0} finished. " +
"TotalWrites = {1}, " +
"TotalMilliseconds = {2}, " +
"Average = {3}, " +
"MaxMilliseconds = {4}, " +
"Bigger500ms = {5}, " +
"Bigger1000ms = {6}",
threadId.ToString("D2"),
totalWrites,
totalMilliseconds,
(double)totalMilliseconds / Math.Max(totalWrites, 1),
maxMilliseconds,
bigger500ms,
bigger1000ms);
}
catch (Exception e)
{
Console.WriteLine("Throws exception " + e.GetType().Name + ". " + e.Message + Environment.NewLine + e.StackTrace);
throw;
}
}
public async Task <IActionResult> Events(EventViewModel model)
{
ViewData["DbAddresult"] = "";
ViewData["Message"] = "Add a new event!";
var user = await userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{userManager.GetUserId(User)}'.");
}
var res = await blockchainRepository.CreateEvent(model.Date.ToTimestamp(), model.TicketAmount,
model.TicketPrice, model.Info, model.IsTicketTradable, model.IsTicketCancelable, model.LastCancelDate.ToTimestamp(), model.Wif);
string owner = await blockchainRepository.GetAddress(model.Wif);
var eventId = await blockchainRepository.GetEventCount();
bool addedToDb = false;
if (res != "smth failed" && eventId != 1000000)
{
Event eve = new Event
{
Id = ++eventId,
Date = model.Date,
TicketAmount = model.TicketAmount,
TicketPrice = model.TicketPrice,
Name = model.Info,
IsTicketCancelable = model.IsTicketCancelable,
IsTicketTradable = model.IsTicketTradable,
LastCancelDate = model.LastCancelDate,
TicketsBought = 0,
TicketsCanceled = 0,
Owner = owner,
Verified = false
};
addedToDb = eventRepository.AddEvent(eve);
}
if (res != "smth failed")
{
model.Link = "https://testnet.qtum.info/tx/" + res;
}
ViewData["Message"] = "Transaction ID:" + res;
if (addedToDb)
{
ViewData["DbAddresult"] = "Added to DB";
}
else
{
ViewData["DbAddresult"] = "Failed to add to DB";
}
model.Events = eventRepository.FindEventsByOwnerId(owner);
return(View(model));
}
public void AddEvent(DTO.Event Event)
{
if (!_events.Exists(e => e.Name.ToUpper().Trim() == Event.Name.ToUpper().Trim()))
{
_eventRepository.AddEvent(Event);
_events = _eventRepository.GetAllEvents();
}
}
public IActionResult OnPost()
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
repo.AddEvent(Event);
return(RedirectToPage("Index"));
}
public IActionResult UploadMobileEvent(MobileEventModel eventModel)
{
if (eventModel.UserId != User.Identity.GetUserId().ToString())
{
return(Unauthorized());
}
ObjectId eventId;
var timeStart = new DateTime
(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var userLocations = new UserEventData
{
Duration = TimeSpan.FromSeconds(eventModel.Duration),
Meters = eventModel.Meters,
UserId = User.Identity.GetUserId(),
Locations = eventModel.Locations.Select(e => new Location
{
Latitude = e.Latitude, Longitude = e.Longitude,
Time = DateTime.SpecifyKind(timeStart.AddMilliseconds(e.TimeMillis), DateTimeKind.Utc)
}).ToList()
};
if (eventModel.EventId == null || !ObjectId.TryParse(eventModel.EventId, out eventId))
{
var e = new Event
{
Finished = true,
OwnerId = User.Identity.GetUserId(),
Name = eventModel.Name,
EndTime = timeStart.AddMilliseconds(eventModel.EndTimeMillis),
Private = true,
StartTime = timeStart.AddMilliseconds(eventModel.StarTimeMillis),
UserEventData = new List <UserEventData>()
{
userLocations
}
};
eventRepository.AddEvent(e);
return(Ok());
}
eventRepository.AddLocationsForEvent(eventId, userLocations);
return(Ok());
}
public IActionResult AddEvent(Event eventToAdd)
{
var eventId = _eventRepository.AddEvent(eventToAdd);
if (eventId != 0)
{
return(Ok(eventId));
}
return(Forbid());
}
public ActionResult <EventDto> CreateEvent([FromBody] EventCreateDto eventCreateDto)
{
var eventEntity = _mapper.Map <Event>(eventCreateDto);
_eventRepository.AddEvent(eventEntity);
_eventRepository.Save();
var eventToReturn = _mapper.Map <EventDto>(eventEntity);
return(CreatedAtRoute("GetEvent", new { id = eventToReturn.Id }, eventToReturn));
}
public override void Execute()
{
var product = _productRepository.GetProduct(ProductId);
product.Deleted = true;
product.LastUpdate = DateTime.Now;
_productRepository.UpdateProduct(product);
_eventRepository.AddEvent(product.ConstructEvent(EventType.Deleted));
Logger.Info("Product deleted: {@id}", ProductId);
}
public IActionResult AddEvent(Event eventToAdd)
{
var wasAddSuccessful = _eventRepository.AddEvent(eventToAdd);
if (wasAddSuccessful)
{
return(Ok());
}
return(Forbid());
}
public IActionResult InsertNewEvent(Event myEvent)
{
if (ModelState.IsValid)
{
if (EventRepository.AddEvent(myEvent) == 1)
{
return(this.Accepted());
}
}
return(BadRequest());
}
public async Task CreateAsync(Guid id, string name, string description, DateTime startDate, DateTime endDate)
{
logger.Info("Creating events");
var eventEntity = await _eventRepository.GetEventByName(name);
if (eventEntity != null)
{
throw new Exception($"Event named: {name} already exist.");
}
eventEntity = new Event(id, name, description, startDate, endDate);
await _eventRepository.AddEvent(eventEntity);
}
public Event AddEvent(Event newEvent, IEnumerable <int> sportIds)
{
var returnedEvent = new Event();
foreach (var id in sportIds)
{
returnedEvent = _repository.AddEvent(newEvent, id);
}
return(returnedEvent);
}
public bool AddEvent(EventDTO eventDTO)
{
try
{
_repository.AddEvent(eventDTO);
}
catch
{
return(false);
}
return(true);
}
public async Task <IActionResult> AddEvent(Event eventParams)
{
if (eventParams == null)
{
return(BadRequest());
}
await eventRepository.AddEvent(eventParams);
await unitOfWork.CompleteAsync();
return(StatusCode(201));
}
