/// <inheritdoc />
public async Task RemoveInvitationsForGroupEventAsync(GroupEvent groupEvent, DateTime utcNow)
{
const string sql = @"
UPDATE Invitation
SET DeletedOnUtc = @DeletedOn, Deleted = @Deleted
WHERE EventId = @EventId AND Deleted = 0";
SqlParameter[] parameters =
{
new SqlParameter("@DeletedOn", utcNow),
new SqlParameter("@Deleted", true),
new SqlParameter("@EventId", groupEvent.Id)
};
await DbContext.ExecuteSqlAsync(sql, parameters);
}
public void OnNewGroupEvent(GroupEvent groupEvent)
{
var group = groupEvent.Group;
switch (groupEvent.Obj.TypeId)
{
case DataObjectType.TimeSeriesItem:
TimeSeriesItem timeSeriesItem = groupEvent.Obj as TimeSeriesItem;
// this.manager.GetLogList(group.Fields["StrategyName"].Value.ToString(), group.Fields["Symbol"].Value.ToString())[group.Fields["LogName"].Value.ToString()].Add(timeSeriesItem.DateTime, (object) timeSeriesItem.Value);
break;
case DataObjectType.Text:
TextInfo textInfo = groupEvent.Obj as TextInfo;
// this.manager.GetLogList(group.Fields["StrategyName"].Value.ToString(), group.Fields["Symbol"].Value.ToString())[group.Fields["LogName"].Value.ToString()].Add(textInfo.DateTime, (object) textInfo.Content);
break;
}
}
public void EditGroupEvent(GroupEvent groupEvent, Product product = null)
{
if (product.ProductID != 0)
{
groupEvent.ProductID = product.ProductID;
}
else
{
listingRepository.InsertProduct(product);
unitOfWork.Save();
groupEvent.ProductID = product.ProductID;
}
siteRepository.UpdateGroupEvent(groupEvent);
unitOfWork.Save();
}
/// <inheritdoc />
public async Task ProduceAsync(int batchSize, CancellationToken cancellationToken = default)
{
IReadOnlyCollection <Attendee> unprocessedAttendees = await _attendeeRepository.GetUnprocessedAsync(batchSize);
if (!unprocessedAttendees.Any())
{
return;
}
IReadOnlyCollection <GroupEvent> groupEvents = await _groupEventRepository.GetForAttendeesAsync(unprocessedAttendees);
if (!groupEvents.Any())
{
return;
}
Dictionary <Guid, GroupEvent> groupEventsDictionary = groupEvents.ToDictionary(g => g.Id, g => g);
var notifications = new List <Notification>();
foreach (Attendee attendee in unprocessedAttendees)
{
Result result = attendee.MarkAsProcessed();
if (result.IsFailure)
{
continue;
}
GroupEvent groupEvent = groupEventsDictionary[attendee.EventId];
List <Notification> notificationsForAttendee = NotificationType
.List
.Select(notificationType => notificationType.TryCreateNotification(groupEvent, attendee.UserId, _dateTime.UtcNow))
.Where(maybeNotification => maybeNotification.HasValue)
.Select(maybeNotification => maybeNotification.Value)
.ToList();
notifications.AddRange(notificationsForAttendee);
}
_notificationRepository.InsertRange(notifications);
await _unitOfWork.SaveChangesAsync(cancellationToken);
}
// GET: GroupEvents/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
GroupEvent groupEvent = db.GroupEvents.Find(id);
if (groupEvent == null)
{
return(HttpNotFound());
}
if (isOwner(groupEvent))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
return(View(groupEvent));
}
public EventSystem(IGenericContext <TEntity> context, GroupEvent type)
{
_context = context;
_type = type;
_isAddType = _type == GroupEvent.Added || _type == GroupEvent.AddedOrRemoved;
_isRemoveType = _type == GroupEvent.Removed || _type == GroupEvent.AddedOrRemoved;
_buffer = new List <TEntity>();
if (_isAddType)
{
_addedCollector = context.GetTriggerCollector <TComponent>(GroupEvent.Added);
}
if (_isRemoveType)
{
_removedCollector = context.GetTriggerCollector <TComponent>(GroupEvent.Removed);
}
}
public void UpdateGUI()
{
if (FrameworkControl.UpdatedSuspened && this.framework.Mode == FrameworkMode.Simulation)
{
return;
}
var evnts = Queue.DequeueAll(this);
if (evnts == null)
{
return;
}
var list1 = new List <GroupEvent>();
for (int i = 0; i < evnts.Length; ++i)
{
Event e = evnts[i];
if (e.TypeId == EventType.GroupEvent)
{
GroupEvent groupEvent = e as GroupEvent;
GroupItem2 groupItem2 = this.table[groupEvent.Group.Id];
string selected = GetComboBoxSelected();
if (selected == null && string.IsNullOrWhiteSpace(groupItem2.SelectorKey) || selected != null && selected == groupItem2.SelectorKey)
{
list1.Add(groupEvent);
}
List <GroupEvent> list2;
if (this.eventsBySelectorKey.TryGetValue(groupItem2.SelectorKey, out list2))
{
list2.Add(groupEvent);
}
}
else if (e.TypeId == EventType.OnFrameworkCleared)
{
list1.Clear();
Reset(false);
}
}
for (int i = 0; i < list1.Count; ++i)
{
ProcessEvent(list1[i], i == list1.Count - 1);
}
SetSeries();
}
/// Creates an Collector and will collect changed entities
/// based on the specified groupEvents.
public Collector(Group[] groups, GroupEvent[] groupEvents)
{
_groups = groups;
_collectedEntities = new HashSet<Entity>(
EntityEqualityComparer.comparer
);
_groupEvents = groupEvents;
if(groups.Length != groupEvents.Length) {
throw new CollectorException(
"Unbalanced count with groups (" + groups.Length +
") and group events (" + groupEvents.Length + ").",
"Group and group events count must be equal."
);
}
_addEntityCache = addEntity;
Activate();
}
public HttpResponseMessage EditGroupEvent([FromBody] EditGroupEventModel editGroupEventModel)
{
GroupEvent groupEventItem = groupEventRepository.GetById(editGroupEventModel.Id);
if (groupEventItem == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Group post with id = " + editGroupEventModel.Id.ToString() + "not found"));
}
else
{
groupEventItem.Title = editGroupEventModel.Title;
groupEventItem.Description = editGroupEventModel.Description;
groupEventItem.TimeForEvent = editGroupEventModel.TimeForEvent;
groupEventItem.Location = editGroupEventModel.Location;
groupEventItem.Picture = editGroupEventModel.Picture;
groupEventRepository.SaveChanges(groupEventItem);
return(Request.CreateResponse(HttpStatusCode.OK));
}
}
public void UpdateGroupEvent(GroupEvent groupEvent)
{
GroupEvent targetGroupEvent = context.GroupEvents.Find(groupEvent.GroupEventID);
if (targetGroupEvent != null)
{
if (groupEvent.EventCreatedTime.CompareTo(default(DateTime)) > 0)
{
targetGroupEvent.EventCreatedTime = groupEvent.EventCreatedTime;
}
targetGroupEvent.Description = groupEvent.Description;
if (groupEvent.EventDate.CompareTo(default(DateTime)) > 0)
{
targetGroupEvent.EventDate = groupEvent.EventDate;
}
targetGroupEvent.EventName = groupEvent.EventName;
targetGroupEvent.IsGameNight = groupEvent.IsGameNight;
targetGroupEvent.ProductID = groupEvent.ProductID;
}
}
/// <inheritdoc />
public async Task <Result> Handle(CreateGroupEventCommand request, CancellationToken cancellationToken)
{
if (request.UserId != _userIdentifierProvider.UserId)
{
return(Result.Failure(DomainErrors.User.InvalidPermissions));
}
if (request.DateTimeUtc <= _dateTime.UtcNow)
{
return(Result.Failure(DomainErrors.GroupEvent.DateAndTimeIsInThePast));
}
Maybe <User> maybeUser = await _userRepository.GetByIdAsync(request.UserId);
if (maybeUser.HasNoValue)
{
return(Result.Failure(DomainErrors.User.NotFound));
}
Maybe <Category> maybeCategory = Category.FromValue(request.CategoryId);
if (maybeCategory.HasNoValue)
{
return(Result.Failure(DomainErrors.Category.NotFound));
}
Result <Name> nameResult = Name.Create(request.Name);
if (nameResult.IsFailure)
{
return(Result.Failure(nameResult.Error));
}
var groupEvent = GroupEvent.Create(maybeUser.Value, nameResult.Value, maybeCategory.Value, request.DateTimeUtc);
_groupEventRepository.Insert(groupEvent);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(Result.Success());
}
public ActionResult CreateEvent([Bind(Include = "Id,Title,Tags")] GroupEvent groupEvent, int?id)
{
if (ModelState.IsValid)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Group group = db.Groups.Find(id);
if (group == null)
{
return(HttpNotFound());
}
var userId = User.Identity.GetUserId();
group.Events.Add(groupEvent);
db.SaveChanges();
return(RedirectToAction("GroupEvents", new { id = id }));
}
return(View(groupEvent));
}
// Token: 0x06000421 RID: 1057 RVA: 0x00014B7C File Offset: 0x00012D7C
public bool PlayAnimation(GroupEvent GroupEvent, float animationSpeed, float animationTime)
{
if (this.movement == null)
{
Debug.Log("no Movement");
return(false);
}
AnimationState animationState;
try
{
if (!this.movement.GetGroupEvent(GroupEvent, ref animationState))
{
return(false);
}
}
catch (NotImplementedException ex)
{
Debug.LogException(ex, this);
return(false);
}
if (animationTime < 0f)
{
animationState.time = -animationTime;
}
else
{
animationState.normalizedTime = animationTime;
}
if (this.animation.Play(animationState.name, 0))
{
if (animationState.speed != animationSpeed)
{
animationState.speed = animationSpeed;
}
return(true);
}
return(false);
}
public bool PlayAnimation(GroupEvent GroupEvent, float animationSpeed, float animationTime)
{
AnimationState state;
if (this.movement == null)
{
Debug.Log("no Movement");
return(false);
}
try
{
if (!this.movement.GetGroupEvent(GroupEvent, out state))
{
return(false);
}
}
catch (NotImplementedException exception)
{
Debug.LogException(exception, this);
return(false);
}
if (animationTime < 0f)
{
state.time = -animationTime;
}
else
{
state.normalizedTime = animationTime;
}
if (!this.animation.Play(state.name, PlayMode.StopSameLayer))
{
return(false);
}
if (state.speed != animationSpeed)
{
state.speed = animationSpeed;
}
return(true);
}
public List <ICmsMenu> ShowSubItems(RenderContext context)
{
List <ICmsMenu> Result = new List <ICmsMenu>();
Result.Add(new GeneralMenu()
{
Name = Hardcoded.GetValue("Overview", context), Url = "Events"
});
var names = Enum.GetNames(typeof(Kooboo.Sites.FrontEvent.enumEventType));
List <GroupEvent> groupnames = new List <GroupEvent>();
foreach (var item in names)
{
GroupEvent eventname = new GroupEvent();
eventname.name = item;
eventname.group = GetEventGroup(item);
groupnames.Add(eventname);
}
foreach (var group in groupnames.GroupBy(o => o.group))
{
var item = new GeneralMenu {
Name = group.Key
};
foreach (var oneevent in group.ToList())
{
item.SubItems.Add(new GeneralMenu
{
Name = oneevent.name,
Url = "Events/Event?name=" + oneevent.name.ToString()
});
}
Result.Add(item);
}
return(Result);
}
public ActionResult DeleteEvent(int?id, int?groupId)
{
if (ModelState.IsValid)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
GroupEvent Event = db.GroupEvents.Find(id);
if (Event == null)
{
return(HttpNotFound());
}
if (isOwner(Event))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
db.GroupEvents.Remove(Event);
db.SaveChanges();
return(RedirectToAction("GroupEvents", new { id = groupId }));
}
return(RedirectToAction("GroupEvents", new { id = groupId }));
}
/// <inheritdoc />
public async Task Handle(AttendeeCreatedIntegrationEvent notification, CancellationToken cancellationToken)
{
Maybe <Attendee> maybeAttendee = await _attendeeRepository.GetByIdAsync(notification.AttendeeId);
if (maybeAttendee.HasNoValue)
{
throw new DomainException(DomainErrors.Attendee.NotFound);
}
Attendee attendee = maybeAttendee.Value;
Maybe <GroupEvent> maybeGroupEvent = await _groupEventRepository.GetByIdAsync(attendee.EventId);
if (maybeGroupEvent.HasNoValue)
{
throw new DomainException(DomainErrors.GroupEvent.NotFound);
}
Maybe <User> maybeUser = await _userRepository.GetByIdAsync(attendee.UserId);
if (maybeUser.HasNoValue)
{
throw new DomainException(DomainErrors.User.NotFound);
}
GroupEvent groupEvent = maybeGroupEvent.Value;
User user = maybeUser.Value;
var attendeeCreatedEmail = new AttendeeCreatedEmail(
user.Email,
user.FullName,
groupEvent.Name,
groupEvent.DateTimeUtc.ToString(CultureInfo.InvariantCulture));
await _emailNotificationService.SendAttendeeCreatedEmail(attendeeCreatedEmail);
}
/// <inheritdoc />
public async Task <Result> Handle(UpdateGroupEventCommand request, CancellationToken cancellationToken)
{
if (request.DateTimeUtc <= _dateTime.UtcNow)
{
return(Result.Failure(DomainErrors.GroupEvent.DateAndTimeIsInThePast));
}
Maybe <GroupEvent> maybeGroupEvent = await _groupEventRepository.GetByIdAsync(request.GroupEventId);
if (maybeGroupEvent.HasNoValue)
{
return(Result.Failure(DomainErrors.GroupEvent.NotFound));
}
GroupEvent groupEvent = maybeGroupEvent.Value;
if (groupEvent.UserId != _userIdentifierProvider.UserId)
{
return(Result.Failure(DomainErrors.User.InvalidPermissions));
}
Result <Name> nameResult = Name.Create(request.Name);
if (nameResult.IsFailure)
{
return(Result.Failure(nameResult.Error));
}
groupEvent.ChangeName(nameResult.Value);
groupEvent.ChangeDateAndTime(request.DateTimeUtc);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(Result.Success());
}
public void OnNewGroupEvent(GroupEvent groupEvent)
{
var groupItem2 = this.table[groupEvent.Group.Id];
object obj;
groupItem2.Table.TryGetValue((int)groupEvent.Obj.TypeId, out obj);
switch (groupEvent.Obj.TypeId)
{
case DataObjectType.Bar:
if (obj == null)
{
obj = new BarSeries(groupItem2.Name, "", -1);
groupItem2.Table.Add((int)groupEvent.Obj.TypeId, obj);
}
(obj as BarSeries).Add(groupEvent.Obj as Bar);
break;
case DataObjectType.Fill:
if (obj == null)
{
obj = new FillSeries(groupItem2.Name);
groupItem2.Table.Add((int)groupEvent.Obj.TypeId, obj);
}
(obj as FillSeries).Add(groupEvent.Obj as Fill);
break;
case DataObjectType.TimeSeriesItem:
if (obj == null)
{
obj = new TimeSeries(groupItem2.Name, "");
groupItem2.Table.Add((int)groupEvent.Obj.TypeId, obj);
}
(obj as TimeSeries).Add((groupEvent.Obj as TimeSeriesItem).DateTime, (groupEvent.Obj as TimeSeriesItem).Value);
break;
}
}
public TriggerOnEvent(IMatcher <TEntity> matcher, GroupEvent groupEvent)
{
this.matcher = matcher;
this.groupEvent = groupEvent;
}
private void ProcessEvent(GroupEvent groupEvent, bool lastEvent)
{
OnNewGroupEvent(groupEvent);
}
public void Post([FromBody] GroupEvent groupEvent)
{
groupEventRepository.Add(groupEvent);
groupEventRepository.SaveChanges(groupEvent);
}
public static ICollector CreateCollector(
this IContext context, IMatcher matcher, GroupEvent groupEvent)
{
return(context.CreateCollector(new TriggerOnEvent(matcher, groupEvent)));
}
public void OnNewGroupEvent(GroupEvent groupEvent)
{
var item = this.table[groupEvent.Group.Id];
Tuple<Viewer, object> tuple = null;
item.Table.TryGetValue(groupEvent.Obj.TypeId, out tuple);
switch (groupEvent.Obj.TypeId)
{
case DataObjectType.Bar:
BarSeries bs;
if (tuple == null)
{
bs = new BarSeries("", "", -1);
int padNumber = item.PadNumber;
EnsurePadExists(padNumber, item.Format);
int viewerIndex = GetViewerIndex(groupEvent.Group, padNumber);
Viewer viewer = this.chart.Pads[padNumber].Insert(viewerIndex, bs as BarSeries);
this.chart.Pads[padNumber].Legend.Add(groupEvent.Group.Name, Color.Black);
item.Table.Add(groupEvent.Obj.TypeId, new Tuple<Viewer, object>(viewer, bs));
}
else
bs = tuple.Item2 as BarSeries;
bs.Add(groupEvent.Obj as Bar);
break;
case DataObjectType.Fill:
FillSeries fs;
if (tuple == null)
{
fs = new FillSeries("");
var padNumber = item.PadNumber;
this.EnsurePadExists(padNumber, item.Format);
var viewerIndex = GetViewerIndex(groupEvent.Group, padNumber);
Viewer viewer = this.chart.Pads[padNumber].Insert(viewerIndex, fs);
item.Table.Add(groupEvent.Obj.TypeId, new Tuple<Viewer, object>(viewer, fs));
}
else
fs = tuple.Item2 as FillSeries;
fs.Add(groupEvent.Obj as Fill);
break;
case DataObjectType.TimeSeriesItem:
TimeSeries ts;
if (tuple == null)
{
ts = new TimeSeries();
var padNumber = item.PadNumber;
EnsurePadExists(padNumber, item.Format);
var viewerIndex = GetViewerIndex(groupEvent.Group, padNumber);
var viewer = this.chart.Pads[padNumber].Insert(viewerIndex, ts);
foreach (var kv in groupEvent.Group.Fields)
viewer.Set(ts, kv.Value.Name, kv.Value.Value);
if (groupEvent.Group.Fields.ContainsKey("Color"))
this.chart.Pads[padNumber].Legend.Add(groupEvent.Group.Name, (Color)groupEvent.Group.Fields["Color"].Value);
else
this.chart.Pads[padNumber].Legend.Add(groupEvent.Group.Name, Color.Black);
item.Table.Add(groupEvent.Obj.TypeId, new Tuple<Viewer, object>(viewer, ts));
}
else
ts = tuple.Item2 as TimeSeries;
ts.Add((groupEvent.Obj as TimeSeriesItem).DateTime, (groupEvent.Obj as TimeSeriesItem).Value);
break;
}
}
private void ProcessEvent(GroupEvent groupEvent, bool lastEvent)
{
OnNewGroupEvent(groupEvent);
if (this.firstDateTime == DateTime.MinValue)
this.firstDateTime = groupEvent.Obj.DateTime;
if (lastEvent)
MoveWindow(groupEvent.Obj.DateTime);
}
private void ProcessEvent(GroupEvent groupEvent, bool lastEvent)
{
OnNewGroupEvent(groupEvent);
}
public void OnNewGroupEvent(GroupEvent groupEvent)
{
var groupItem2 = this.table[groupEvent.Group.Id];
object obj;
groupItem2.Table.TryGetValue((int)groupEvent.Obj.TypeId, out obj);
switch (groupEvent.Obj.TypeId)
{
case DataObjectType.Bar:
if (obj == null)
{
obj = new BarSeries(groupItem2.Name, "", -1);
groupItem2.Table.Add((int)groupEvent.Obj.TypeId, obj);
}
(obj as BarSeries).Add(groupEvent.Obj as Bar);
break;
case DataObjectType.Fill:
if (obj == null)
{
obj = new FillSeries(groupItem2.Name);
groupItem2.Table.Add((int)groupEvent.Obj.TypeId, obj);
}
(obj as FillSeries).Add(groupEvent.Obj as Fill);
break;
case DataObjectType.TimeSeriesItem:
if (obj == null)
{
obj = new TimeSeries(groupItem2.Name, "");
groupItem2.Table.Add((int)groupEvent.Obj.TypeId, obj);
}
(obj as TimeSeries).Add((groupEvent.Obj as TimeSeriesItem).DateTime, (groupEvent.Obj as TimeSeriesItem).Value);
break;
}
}
public GroupController(UserLoggedEvent userLoggedEvent, GroupUserEvent groupUserEvent, GroupEvent groupEvent)
{
_userLoggedEvent = userLoggedEvent;
_groupUserEvent = groupUserEvent;
_groupEvent = groupEvent;
}
/// <summary> /// Initializes a new instance of the <see cref="GroupEventCreatedDomainEvent"/> class. /// </summary> /// <param name="groupEvent">The group event.</param> internal GroupEventCreatedDomainEvent(GroupEvent groupEvent) => GroupEvent = groupEvent;
public static ICollector CreateCollector(this IGroup group, GroupEvent groupEvent = GroupEvent.Added)
{
return(new Collector(group, groupEvent));
}
/// Creates an Collector.
public static Collector CreateCollector(this Context context, IMatcher matcher, GroupEvent groupEvent = GroupEvent.Added)
{
return new Collector(context.GetGroup(matcher), groupEvent);
}
/// <inheritdoc />
public async Task <(string Email, string Name)[]> GetEmailsAndNamesForGroupEvent(GroupEvent groupEvent)
{
if (groupEvent.Id == Guid.Empty)
{
return(Array.Empty <(string, string)>());
}
var attendeeEmailsAndNames = await(
from @event in DbContext.Set <GroupEvent>()
join attendee in DbContext.Set <Attendee>()
on groupEvent.Id equals attendee.EventId
join user in DbContext.Set <User>()
on attendee.UserId equals user.Id
where @event.Id == groupEvent.Id && attendee.UserId != groupEvent.UserId
select new
{
Email = user.Email.Value,
Name = user.FirstName.Value + " " + user.LastName.Value
}).ToArrayAsync();
return(attendeeEmailsAndNames.Select(x => (x.Email, x.Name)).ToArray());
}
/// Creates an Collector and will collect changed entities
/// based on the specified groupEvent.
public Collector(Group group, GroupEvent groupEvent)
: this(new [] { group }, new [] { groupEvent })
{
}
/// Creates an Collector.
public static Collector CreateCollector(this Context context, IMatcher matcher, GroupEvent groupEvent = GroupEvent.Added)
{
return(new Collector(context.GetGroup(matcher), groupEvent));
}
/// Creates an Collector for this group.
public static Collector CreateCollector(
this Group group,
GroupEvent groupEvent = GroupEvent.Added)
{
return new Collector(group, groupEvent);
}
