// [Authorize]
public async Task <IActionResult> Unclaim([FromRoute] int id)
{
var user = await GetCurrentUserAsync();
// Uncomment for testing
// ApplicationUser user = await context.ApplicationUser.SingleAsync(u => u.FirstName == "Matt");
EventMember eMember = await context.EventMember.Include(e => e.ApplicationUser).Where(e => e.EventMemberId == id && e.ApplicationUser == user).SingleOrDefaultAsync();
if (eMember == null)
{
return(BadRequest(new
{
Error = $"You are not signed up for this event.",
StatusCode = "400"
}));
}
eMember.ApplicationUser = null;
context.Entry(eMember).State = EntityState.Modified;
context.Update(eMember);
await context.SaveChangesAsync();
return(Json(new EventMemberViewModel(eMember)));
}
public ServiceResult InsertEventMember(INode n)
{
if (!this.DataAccessAuthorized(n, "post", false))
{
return(ServiceResponse.Error("You are not authorized this action."));
}
n.Initialize(this._requestingUser.UUID, this._requestingUser.AccountUUID, this._requestingUser.RoleWeight);
var s = (EventMember)n;
using (var context = new GreenWerxDbContext(this._connectionKey))
{
EventMember dbU = context.GetAll <EventMember>()?.
FirstOrDefault(wu => wu.EventUUID == s.EventUUID && wu.UserUUID == s.UserUUID && wu.AccountUUID == s.AccountUUID);
if (dbU != null)
{
return(ServiceResponse.Error("EventMember already exists."));
}
if (context.Insert <EventMember>(s))
{
return(ServiceResponse.OK("", s));
}
}
return(ServiceResponse.Error("An error occurred inserting EventMember " + s.Name));
}
public void CreateMember(EventModel Data, List <string> inviteesIds)
{
try
{
EventMember member = new EventMember();
List <EventMember> MemberList = new List <EventMember>();
foreach (var id in inviteesIds)
{
MemberList.Add(new EventMember()
{
MemberID = id,
EventId = Data.EventId,
ResponseDate = DateTime.Now,
PerticipetingType = null,
});
}
_data.EventMember.AddRange(MemberList);
_data.SaveChanges();
}
catch (Exception ex)
{
throw;
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,EventId,ApplicationUserId")] EventMember eventMember)
{
if (id != eventMember.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(eventMember);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EventMemberExists(eventMember.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(eventMember));
}
public bool MemberResponse(int Id, string Response)
{
try
{
var perticipent = _data.EventMember.FirstOrDefault(x => x.EventId == Id && x.MemberID == Current_User_id);
if (perticipent != null)
{
perticipent.PerticipetingType = Response;
perticipent.ResponseDate = DateTime.Now;
_data.SaveChanges();
}
else
{
EventMember NewPerticipent = new EventMember();
NewPerticipent.EventId = Id;
NewPerticipent.MemberID = Current_User_id;
NewPerticipent.PerticipetingType = Response;
NewPerticipent.ResponseDate = DateTime.Now;
_data.EventMember.Add(NewPerticipent);
_data.SaveChanges();
}
return(true);
}
catch
{
return(false);
}
}
public async Task <ServiceResult> AddUsersToEvent(string eventUUID)
{
if (CurrentUser == null)
{
return(ServiceResponse.Error("You must be logged in to access this function."));
}
List <EventMember> members = new List <EventMember>();
ServiceResult res;
try
{
string content = await Request.Content.ReadAsStringAsync();
if (content == null)
{
return(ServiceResponse.Error("No users were sent."));
}
string body = content;
if (string.IsNullOrEmpty(body))
{
return(ServiceResponse.Error("No users were sent."));
}
List <User> users = JsonConvert.DeserializeObject <List <User> >(body);
EventManager eventManager = new EventManager(Globals.DBConnectionKey, this.GetAuthToken(Request));
var res2 = eventManager.Get(eventUUID);
var evt = res2.Result as Event;
foreach (var user in users)
{
var member = new EventMember
{
AccountUUID = CurrentUser.AccountUUID,
Active = true,
CreatedBy = CurrentUser.UUID,
RoleOperation = "=",
UserUUID = user.UUID,
Image = user.Image,
Name = user.Name,
EventUUID = eventUUID,
Private = evt.Private,
DateCreated = DateTime.UtcNow,
NSFW = evt.NSFW,
RoleWeight = RoleFlags.MemberRoleWeights.Member
};
eventManager.InsertEventMember(member);
members.Add(member);
}
}
catch (Exception ex)
{
Debug.Assert(false, ex.Message);
return(ServiceResponse.Error(ex.Message));
}
return(ServiceResponse.OK("", members));
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
protected override void OnEvent(EventMember member, Func <EventDecorationBuilder> decorate)
{
Local <EventInterceptorClosure <TypeTemplate.TEventArgs> > interceptorClosure = null;
Argument <EventHandler <TypeTemplate.TEventArgs> > value = null;
decorate().OnAdd()
.OnBefore(w => {
value = w.Arg1 <EventHandler <TypeTemplate.TEventArgs> >();
interceptorClosure = w.Local <EventInterceptorClosure <TypeTemplate.TEventArgs> >();
interceptorClosure.Assign(w.New <EventInterceptorClosure <TypeTemplate.TEventArgs> >());
interceptorClosure.Field(x => x.EventName).Assign(member.Name);
interceptorClosure.Field(x => x.Log).Assign(m_LogField);
interceptorClosure.Field(x => x.Handler).Assign(value);
value.Assign(
w.MakeDelegate <EventInterceptorClosure <TypeTemplate.TEventArgs>, EventHandler <TypeTemplate.TEventArgs>, TypeTemplate.TEventHandler>(
interceptorClosure,
x => x.HandleEvent
)
);
})
.OnSuccess(w =>
m_EventHandlerMapField.Add(interceptorClosure.Field(x => x.Handler), value)
);
decorate().OnRemove()
.OnBefore(w => {
value = w.Arg1 <EventHandler <TypeTemplate.TEventArgs> >();
var interceptingHandler = w.Local <EventHandler <TypeTemplate.TEventArgs> >();
w.If(m_EventHandlerMapField.TryGetValue(value, interceptingHandler) == w.Const(true)).Then(() =>
value.Assign(interceptingHandler)
);
});
}
// [Authorize]
public async Task <IActionResult> Delete([FromRoute] int id)
{
// Confirm that the logged in user is the organizer
var user = await GetCurrentUserAsync();
// For testing purposes
// ApplicationUser user = await context.ApplicationUser.SingleOrDefaultAsync(u => u.FirstName == "Steve");
EventMember eMember = await context.EventMember
.Include(e => e.Event)
.ThenInclude(ev => ev.Organization).ThenInclude(o => o.Organizer)
.Where(e => e.EventMemberId == id && e.Event.Organization.Organizer.Id == user.Id)
.SingleOrDefaultAsync();
if (eMember == null)
{
return(new ForbidResult($"Can't delete event member with ID {id}"));
}
// Delete event member and chatroom messages associated
EventChatroomMessage[] chatMessages = await(
from messages in context.EventChatroomMessage.Include(m => m.Author)
where eMember.ApplicationUser != null && messages.AuthorId == eMember.ApplicationUser.Id
select messages
).ToArrayAsync();
if (chatMessages != null && chatMessages.Length > 0)
{
context.RemoveRange(chatMessages);
}
context.Remove(eMember);
await context.SaveChangesAsync();
return(new NoContentResult());
}
public async Task <IActionResult> GetById([FromRoute] int id)
{
EventMember eMember = await context.EventMember.Include(e => e.ApplicationUser).Where(e => e.EventMemberId == id).SingleOrDefaultAsync();
EventMemberViewModel model = new EventMemberViewModel(eMember);
return(Json(model));
}
public ActionResult DeleteConfirmed(int id)
{
EventMember eventMember = db.EventMembers.Find(id);
db.EventMembers.Remove(eventMember);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public AbstractExpression DOT(EventMember @event)
{
return(new MemberExpression()
{
Target = this,
Member = @event,
Type = @event.DelegateType
});
}
public void DeleteMemberFromEvent(Guid eventId, Member member, string username)
{
var ev = GetUserEventById(eventId, username);
var eventMember = new EventMember {
Member = member, Event = ev, EventId = ev.Id, MemberId = member.Id
};
_context.EventMembers.Remove(eventMember);
}
/* USERS JOIN REQUESTS */
public async Task AcceptJoinRequest(EventMember eventMember)
{
using (var context = ContextFactory.CreateDbContext(ConnectionString))
{
var row = context.EventMembers.Where(e => e.EventId == eventMember.EventId && e.UserId == eventMember.UserId).Single();
row.Status = true;
context.EventMembers.Update(row);
await context.SaveChangesAsync();
}
}
public async Task DeclineJoinRequest(EventMember eventMember)
{
using (var context = ContextFactory.CreateDbContext(ConnectionString))
{
var row = context.EventMembers.Where(e => e.EventId == eventMember.EventId && e.UserId == eventMember.UserId).Single();
context.EventMembers.Remove(row);
await context.SaveChangesAsync();
}
}
public AutomaticEventWriter(EventMember ownerEvent)
: base(ownerEvent)
{
var addOn = new VoidMethodWriter(
OwnerEvent.AddMethod,
w => WriteAddRemoveMethod(w, w.Arg1 <TypeTemplate.TEventHandler>(), manipulation: Delegate.Combine));
var removeOn = new VoidMethodWriter(
OwnerEvent.RemoveMethod,
w => WriteAddRemoveMethod(w, w.Arg1 <TypeTemplate.TEventHandler>(), manipulation: Delegate.Remove));
}
public async Task <IActionResult> JoinEvent(int id, JoinEventViewModel model)
{
var evt = await _dbContext.Events.FindAsync(id);
if (evt == null)
{
_logger.LogInformation($"Event ID {id} not found");
// TODO: Display error
return(RedirectToAction(nameof(Index)));
}
model.Event = evt.ToModel();
var currentUser = await _userManager.GetUserAsync(User);
var userIsMember = await _dbContext.EventMembers.AnyAsync(x => x.EventId == evt.Id && x.UserId == currentUser.Id);
if (userIsMember)
{
_logger.LogInformation($"User ID {currentUser.Id} is already member of Event ID {evt.Id}");
return(RedirectToAction(nameof(Details), new { slug = evt.Slug }));
}
if (evt.RequirePassword && model.Password != evt.JoinPassword)
{
ModelState.AddModelError(nameof(model.Password), "Event password is invalid");
return(View(model));
}
try
{
var member = new EventMember
{
EventId = evt.Id,
UserId = currentUser.Id,
JoinDate = DateTime.UtcNow,
JoinMethod = EventMemberJoinMethod.Password
};
_dbContext.EventMembers.Add(member);
await _dbContext.SaveChangesAsync();
// TODO: show success message
return(RedirectToAction(nameof(Details), new { slug = evt.Slug }));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error joining user ID {currentUser.Id} to event ID {evt.Id}");
return(View(model));
}
}
public ActionResult Edit([Bind(Include = "UserUserId,EventEventId")] EventMember eventMember)
{
if (ModelState.IsValid)
{
db.Entry(eventMember).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.UserUserId = new SelectList(db.Users, "UserId", "FirstName", eventMember.UserUserId);
ViewBag.EventEventId = new SelectList(db.Events, "EventId", "EventName", eventMember.EventEventId);
return(View(eventMember));
}
public IActionResult AddMember(int idEvent, EventMember member)
{
if (_context.Events.Find(idEvent) == null)
{
return(NotFound());
}
member.EventID = idEvent;
_context.EventMembers.Add(member);
_context.SaveChanges();
return(Ok());
}
protected override IntermediateClassType <TInstanceIntermediateType> .EventMember GetNewEvent(string name, TypedNameSeries eventSignature)
{
var result = new EventMember(((TInstanceIntermediateType)(object)this))
{
SignatureSource = EventSignatureSource.Declared,
Name = name
};
foreach (var param in eventSignature)
{
result.Parameters.Add(param.Name, param.GetTypeRef(), param.Direction);
}
return(result);
}
// GET: EventMembers/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EventMember eventMember = db.EventMembers.Find(id);
if (eventMember == null)
{
return(HttpNotFound());
}
return(View(eventMember));
}
public void DeleteEventMember(EventMember member)
{
try
{
using (var context = new GreenWerxDbContext(this._connectionKey))
{
context.Delete <EventMember>(member);
}
}
catch (Exception ex)
{
Debug.Assert(false, ex.Message);
}
}
public void ReadDeclaration()
{
_adderReader = MethodReaderMechanism.CreateAccessorMethodReader(_modelBuilder, _symbol.AddMethod);
_removerReader = MethodReaderMechanism.CreateAccessorMethodReader(_modelBuilder, _symbol.RemoveMethod);
_member = new EventMember {
Name = _symbol.Name,
DeclaringType = _modelBuilder.TryGetMember <TypeMember>(_symbol.ContainingType),
Status = MemberStatus.Incomplete,
Visibility = _symbol.GetMemberVisibility(),
Modifier = _symbol.GetMemberModifier(),
DelegateType = _modelBuilder.TryGetMember <TypeMember>(_symbol.Type),
};
}
public async Task <bool> AddEventMember(EventMemberViewModel objEventMemberViewModel)
{
var objEventMember = new EventMember
{
UserId = objEventMemberViewModel.UserId,
EventId = objEventMemberViewModel.EventId,
CreatedDate = DateTime.Now,
IsActive = objEventMemberViewModel.IsActive
};
this._entities.EventMembers.Add(objEventMember);
await this._entities.SaveChangesAsync();
return(true);
}
public UserEventMemberViewModel(EventMember e)
{
Event = new EventViewModel(e.Event);
EventMemberId = e.EventMemberId;
if (e.ApplicationUser != null)
{
Volunteer = new ApplicationUserViewModel(e.ApplicationUser);
}
JobTitle = e.JobTitle;
Description = e.Description;
StartTime = e.StartTime;
EndTime = e.EndTime;
ChatMuted = e.ChatMuted;
AttendeePoints = e.AttendeePoints;
}
public TemplateEventWriter(
EventMember ownerEvent,
Func <TemplateEventWriter, EventWriterBase.IEventWriterAddOn> addScript,
Func <TemplateEventWriter, EventWriterBase.IEventWriterRemoveOn> removeScript)
: base(ownerEvent)
{
if (addScript != null)
{
addScript(this);
}
if (removeScript != null)
{
removeScript(this);
}
}
public EventMemberViewModel(EventMember e)
{
EventId = e.EventId;
EventMemberId = e.EventMemberId;
if (e.ApplicationUser != null)
{
Volunteer = new ApplicationUserViewModel(e.ApplicationUser);
}
JobTitle = e.JobTitle;
Description = e.Description;
StartTime = e.StartTime;
Timestamp = e.StartTime.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
EndTime = e.EndTime;
ChatMuted = e.ChatMuted;
AttendeePoints = e.AttendeePoints;
}
public IActionResult UpdateMember(int idEvent, int idMember, EventMember member)
{
var eventMember = _context.EventMembers
.SingleOrDefault(m => m.EventID == idEvent && m.UserID == idMember);
if (eventMember == null)
{
return(NotFound());
}
eventMember.Standby = member.Standby;
_context.EventMembers.Update(eventMember);
_context.SaveChanges();
return(Ok());
}
// GET: EventMembers/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EventMember eventMember = db.EventMembers.Find(id);
if (eventMember == null)
{
return(HttpNotFound());
}
ViewBag.UserUserId = new SelectList(db.Users, "UserId", "FirstName", eventMember.UserUserId);
ViewBag.EventEventId = new SelectList(db.Events, "EventId", "EventName", eventMember.EventEventId);
return(View(eventMember));
}
public async Task <IActionResult> JoinEvent(int userId, int teamId, int eventId)
{
if (userId == 0 || teamId == 0)
{
return(BadRequest());
}
if (userId != int.Parse(User.FindFirst(ClaimTypes.Name)?.Value))
{
return(Unauthorized());
}
if (!await _tRepo.IsTeamOwner(userId))
{
return(Unauthorized(new { message = "You're not the owner of this team." }));
}
if (!await _tRepo.TeamExists(teamId))
{
return(BadRequest(new { message = "Team does not exist" }));
}
if (await _tRepo.IsTeamMember(userId, teamId))
{
return(Unauthorized(new { message = "You're already part of this Team" }));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var member = new EventMember()
{
UserId = userId,
EventId = eventId,
TeamId = teamId
};
if (!await _tRepo.JoinEvent(member))
{
return(StatusCode(500, ModelState));
}
return(Ok(member));
}
public async Task <IActionResult> JoinEvent(int userId, int eventId)
{
if (userId == 0 || eventId == 0)
{
return(BadRequest());
}
if (userId != int.Parse(User.FindFirst(ClaimTypes.Name)?.Value))
{
return(Unauthorized());
}
if (!await _evRepo.UserIdExists(userId))
{
return(Unauthorized(new { message = "User does not exist." }));
}
if (!await _evRepo.EventExists(eventId))
{
return(BadRequest(new { message = "Event does not exist" }));
}
if (await _evRepo.IsEventMember(userId, eventId))
{
return(Unauthorized(new { message = "You're already part of this Event" }));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var member = new EventMember()
{
UserId = userId,
EventId = eventId
};
if (!await _evRepo.JoinEvent(member))
{
return(StatusCode(500, ModelState));
}
return(Ok(member));
}
public void SaveEventMemberFailure()
{
SetupSaveEventMemberFailure();
var invalidEventMember = new EventMember {User = null, Event = null};
ValidateUnsuccessfulEntityCreation(_eventService.SaveEventMember(invalidEventMember));
}
public void OnDetectDifference(EventMember member)
{
switch (member)
{
case EventMember.ZoomInfo:
Debug.WriteLine("Difference detected: zoom");
NoticeUpdate();
break;
case EventMember.CameraStatus:
Debug.WriteLine("CameraStatus has changed: " + _cameraStatus.Status);
break;
default:
//Debug.WriteLine("Difference detected: default");
break;
}
}
public EventMember SaveEventMember(EventMember validEventMember)
{
return ValidateAndSave(validEventMember);
}
public void SaveEventMemberSuccess()
{
SetupSaveEventMemberSuccess();
var validEventMember = new EventMember { User = new User(), Event = new Event(), Status = Entities.Enumerations.EventMemberStatus.Requested };
ValidateSuccessfulEntityCreation(_eventService.SaveEventMember(validEventMember));
}
private void NotifyChangeDetected(EventMember target)
{
//Debug.WriteLine("NotifyChangeDetected: " + target);
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
if (OnDetectDifference != null)
{ OnDetectDifference.Invoke(target); }
});
}
private EventMember ParseInvitedEventMember(string identifier)
{
string emailAddress = null;
long facebookId = 0;
long existingUserId;
if (!Int64.TryParse(identifier, out existingUserId))
{
if (identifier.StartsWith("fb_"))
{
if (!Int64.TryParse(identifier, out facebookId))
{
AddValidationResult(facebookId + " is not a valid facebook ID.", null);
return null;
}
}
else if (!IsEmail(identifier))
{
AddValidationResult(identifier + " is not a valid email address.", null);
return null;
}
else
emailAddress = identifier;
}
long? nullableFacebokId = null;
if (facebookId != 0) nullableFacebokId = facebookId;
var user = existingUserId == 0 ? null : AccountService.GetUserById(existingUserId);
EventMember eventMember;
if (user != null && user.MemberEvents.Any(x => x.Event == _event))
{
eventMember = user.MemberEvents.FirstOrDefault(x => x.Event == _event);
eventMember.Status = EventMemberStatus.Invited;
eventMember.LastStatusChange = DateTime.Now;
}
else
eventMember = new EventMember
{
EmailAddress = emailAddress,
Event = _event,
FacebookUser = nullableFacebokId,
LastStatusChange = DateTime.Now,
Status = EventMemberStatus.Invited,
User = user
};
return eventMember;
}
