public async Task <IActionResult> checkIfUserAttended(string RFID)
{
try
{
// check if user has signed up
UserEvents eventExist = await getParticipant(RFID);
//if user found update isAttended
if (eventExist != null)
{
// check if event date is past date or it is within 24 hrs from today
var eventDate = dbContext.Events.SingleOrDefault(a => a.EventId == eventExist.EventId).DateTime;
if ((eventDate - DateTime.Now).TotalDays < 2 && eventDate > DateTime.Today)
{
eventExist.IsAttended = "Y";
await dbContext.SaveChangesAsync();
return(Ok("Registration Successful!!!"));
}
return(BadRequest("Event is either past event or you are checking up early..Check in start before 24 hrs of event day"));
}
// post userevent details to table and return RFIDTag
return(NotFound("You have not signed up for the event"));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public Event Create(EventRequest element, string userId)
{
var eventId = Guid.NewGuid().ToString();
Event @event = new Event
{
Address = element.Address,
Description = element.Description,
EndDate = element.EndDate,
EventId = eventId,
Name = element.Name,
StartDate = element.StartDate,
};
_botEventManagementContext.Event.Add(@event);
_botEventManagementContext.SaveChanges();
var userEvent = new UserEvents
{
EventId = eventId,
UserId = userId
};
_botEventManagementContext.UserEvents.Add(userEvent);
_botEventManagementContext.SaveChanges();
return(@event);
}
public async Task <IActionResult> PutUserEvents([FromRoute] int id, [FromBody] UserEvents userEvents)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != userEvents.UserEventId)
{
return(BadRequest());
}
_context.Entry(userEvents).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserEventsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> CreateEvent([FromForm] UserEvents userEvents, [FromHeader] string authorization)
{
try {
string apiKey;
if (authorization == null)
{
_logger.LogDebug("User with apiKey:{$apiKey} received this event response:{message}", authorization, "Access denied...");
return(Unauthorized("Access denied..."));
}
else
{
apiKey = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value;
_logger.LogInformation("User with apiKey:{$apiKey} sent this event request:{@userEvents}", apiKey, userEvents);
}
if (await _repositoryEvent.CreateEvent(userEvents) == "EventId already exists")
{
_logger.LogDebug("User with apiKey:{$apiKey} received this event response:{message}", apiKey, "Event belongs to another user...");
return(BadRequest("Event belongs to another user..."));
}
else
{
_logger.LogInformation("User with apiKey:{$apiKey} received this event response:{message}", apiKey, "Event have been created...");
return(Ok("Event have been created..."));
}
}
catch (Exception exception)
{
_logger.LogError("Exception message:{exception}", exception);
throw;
}
}
public async Task <ActionResult> Going(int EventId)
{
var userManager = this.UserManager;
var userId = User.Identity.GetUserId();
var user = await UserManager.FindByIdAsync(userId);
UserEvents userEvents = new UserEvents();
userEvents.Id = user.Id;
userEvents.EventId = EventId;
Event thisevent = await _db.Events.SingleOrDefaultAsync(x => x.EventId == EventId);
if (!ModelState.IsValid)
{
return(Json(new { Success = false, Message = "Invalid Data" }));
}
else
{
if (thisevent.Going != null)
{
++thisevent.Going;
}
else
{
thisevent.Going = 1;
}
_db.UserEvents.Add(userEvents);
await _db.SaveChangesAsync();
return(Json(new { Success = true, Message = "Message Sent", Going = thisevent.Going }));
}
}
public async Task <ActionResult> CancelGoing(int CancelledEventId)
{
var userManager = this.UserManager;
var userId = User.Identity.GetUserId();
var user = await UserManager.FindByIdAsync(userId);
Event thisevent = await _db.Events.SingleOrDefaultAsync(x => x.EventId == CancelledEventId);
List <UserEvents> AllUserEvents = await _db.UserEvents.Where(x => x.EventId == CancelledEventId).ToListAsync();
UserEvents removeUserEvent = AllUserEvents.SingleOrDefault(x => x.Id == userId);
if (!ModelState.IsValid)
{
return(Json(new { Success = false, Message = "Invalid Data" }));
}
else
{
if (thisevent.Going != null)
{
--thisevent.Going;
}
_db.UserEvents.Remove(removeUserEvent);
await _db.SaveChangesAsync();
return(Json(new { Success = true, Message = "Message Sent", Going = thisevent.Going }));
}
}
public EventSnippets UserActiveEvent(string UserID)
{
UserEvents activeEvent = db.UserEvents.Include(x => x.Event).Where(x => x.UserID == UserID && !x.Finished).FirstOrDefault();
if (activeEvent == null)
{
return(null);
}
if (activeEvent.Event.End < Utilities.DateHelper.GetCurrentTime())
{
activeEvent.Finished = true;
db.SaveChanges();
return(null);
}
EventSnippets result = db.UserEvents.Include(x => x.Event).Include(x => x.Event.EventSnippets).Where(x => x.UserID == UserID && !x.Finished)
.SelectMany(x => x.Event.EventSnippets.Where(y => y.OrderNumber == x.Event.EventSnippets.Max(t => t.OrderNumber))).FirstOrDefault();
//if()
//EventSnippets result = activeEvent.Event.EventSnippets.SelectMany(x => x.Event.EventSnippets.Where(y => y.OrderNumber == x.Event.EventSnippets.Max(t => t.OrderNumber))).FirstOrDefault();
return(result);
}
public UserEvents joinUserToEvent(int userId, int eventId)
{
UserEvents userEvents = new UserEvents(userId, eventId);
db.userEvents.Add(userEvents);
db.SaveChanges();
return(userEvents);
}
public void Enable()
{
if (!_disabled)
{
throw new AggregateException(string.Format("User {0} is already enabled", _id));
}
ApplyChange(UserEvents.Enabled(_id));
}
public static User CreateBasicUser(UserId gpid, string emailAddress, int metroId)
{
// do any business logic to protect invariants
// note: validation, like email address is well formed, is not something that should be done in here -
// that should be taken care of before this method is invoked
var user = Factory();
user.ApplyChange(UserEvents.Created(emailAddress, gpid, metroId, false));
return(user);
}
private void StartButton_Click(object sender, RoutedEventArgs e)
{
TestManager TM = new TestManager();
UserEvents.OnUserStartedTest(this, new StartedTestEventArgs("Hadi", "Medium"));
Test t = new Test(TM);
t.Show();
}
public List <UserEvents> GetByUser(string UserId)
{
List <UserEvents> list = null;
DataProvider.ExecuteCmd(GetConnection, "dbo.UserEvents_Select"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@UserId", UserId);
}, map : delegate(IDataReader reader, short set) //executes after stored proc
{
UserEvents p = new UserEvents();
int startingIndex = 0; //startingOrdinal
// e.Id - int
//,e.UserId - string
//,e.EventType - int
//,e.isPublic - bool
//,e.Title - string
//,e.Description - string
//,e.Start - DateTime
//,e.[End] - DateTime
//,a.RsvpStatus - int
p.Id = reader.GetSafeInt32(startingIndex++);
p.UserId = reader.GetSafeString(startingIndex++);
p.EventType = reader.GetSafeInt32(startingIndex++);
p.isPublic = reader.GetSafeBool(startingIndex++);
p.Title = reader.GetSafeString(startingIndex++);
p.Description = reader.GetSafeString(startingIndex++);
p.Start = reader.GetSafeDateTime(startingIndex++);
p.End = reader.GetSafeDateTime(startingIndex++);
p.RsvpStatus = reader.GetSafeInt32(startingIndex++);
Location l = new Location();
l.Id = reader.GetSafeInt32(startingIndex++);
l.Latitude = reader.GetSafeDecimalNullable(startingIndex++);
l.Longitude = reader.GetSafeDecimalNullable(startingIndex++);
l.Address = reader.GetSafeString(startingIndex++);
l.City = reader.GetSafeString(startingIndex++);
l.State = reader.GetSafeString(startingIndex++);
l.ZipCode = reader.GetSafeString(startingIndex++);
p.location = l;
if (list == null)
{
list = new List <UserEvents>();
}
list.Add(p);
}
);
return(list);
}
public List <UserEvents> GetEventsFromDatabase(string user_ip)
{
try
{
List <UserEvents> list_events = new List <UserEvents>();
using (SqlConnection conn = CONNECTION)
{
try
{
conn.Open();
SqlCommand get_events_command = new SqlCommand("dbo.SEL_USERS_EVENTS", conn);
get_events_command.CommandType = CommandType.StoredProcedure;
SqlParameter user_name = new SqlParameter
{
ParameterName = "@user_name",
Value = user_ip,
SqlDbType = SqlDbType.VarChar
};
get_events_command.Parameters.Add(user_name);
var reader = get_events_command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
var t = new UserEvents(Convert.ToChar(reader["operation_char"]));
t.ID = Convert.ToInt32(reader["user_events_id"]);
t.User = new Service.UserClass.User(Convert.ToString(reader["users_name"]));
t.Operation.A_number = Convert.ToDouble(reader["a_number"]);
t.Operation.B_number = Convert.ToDouble(reader["b_number"]);
t.Operation.Result = Convert.ToDouble(reader["result"]);
t.DateTimeOperation = Convert.ToDateTime(reader["dattim"]);
list_events.Add(t);
}
return(list_events);
}
else
{
throw new Exception("In database have not any events with IP " + user_ip);
}
}
catch (SqlException ex)
{
throw new Exception(ex.Message);
}
catch (Exception)
{
throw;
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> postEventsByUser([FromBody] addevent ue)
{
// create object for weatherForecast controller
var weatherObj = new ExternalServicesController();
try
{
// get event details by Id
var ev = dbContext.Events.SingleOrDefault(a => a.EventId == ue.EventId);
// get event date from event id
DateTime evDate = ev.DateTime;
// get details of user by id
var usr = dbContext.Users.SingleOrDefault(a => a.UserId == ue.GuestId);
//if event is having past date show error
if (evDate < DateTime.Today)
{
return(BadRequest("Event is past and already done"));
}
// check if user has already signed up
var eventExist = await dbContext.UserEvents.SingleOrDefaultAsync(c => c.GuestId == ue.GuestId& c.EventId == ue.EventId);
//if event is already signed up by user send error
if (eventExist != null)
{
return(BadRequest("User has already signed up for the event"));
}
Guid g = Guid.NewGuid();
// post userevent details to table and return RFIDTag
var userevent = new UserEvents
{
GuestId = ue.GuestId,
EventId = ue.EventId,
RFIDTagId = g.ToString()
};
// save details to database
dbContext.UserEvents.Add(userevent);
await dbContext.SaveChangesAsync();
// send email to user
weatherObj.SendEmail(usr.EmailAddress, usr.FirstName, ev.EventName, "registered").Wait();
// add custome header
Response.Headers.Add("RFID", userevent.RFIDTagId);
return(Ok(new { RFID = userevent.RFIDTagId }));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public UserController(UserEvents UserRepository,
GroupUserEvent groupUserEvent,
UserLoggedEvent userLoggedEvent,
GroupEvent groupEvent)
{
_groupEvent = groupEvent;
_userRepository = UserRepository;
_groupUserEvent = groupUserEvent;
_userLoggedEvent = userLoggedEvent;
_object = new ResultModel <Domain.Client.DTO.User>();
}
private void AnalyzeAnswer(object sender, AnswerEventArgs e)
{
if (TheTestStats.CurrentEquation.Answer == e.Answer)
{
UserEvents.OnUserGotQuestionRight(this, e);
}
else if (TheTestStats.CurrentEquation.Answer != e.Answer)
{
UserEvents.OnUserGotQuestionWrong(this, e);
}
}
public void Delete(string userId, string eventId)
{
UserEvents userEvents = _botEventManagementContext.UserEvents.Where(x => x.EventId == eventId && x.UserId == userId).First();
_botEventManagementContext.UserEvents.Remove(userEvents);
Event @event = _botEventManagementContext.Event.Where(x => x.EventId == eventId).First();
_botEventManagementContext.Event.Remove(@event);
_botEventManagementContext.SaveChanges();
}
public void DisableUser()
{
var id = new UserId(Guid.NewGuid());
var email = "*****@*****.**";
var metroId = 11;
new CommandScenarioFor <User>(User.Factory)
.Given(UserEvents.Created(email, id, metroId, false))
.When(user => user.Disable())
.Then(UserEvents.Disabled(id))
.Assert();
}
public void AddFriend(UserId userId, UserId friendsId, string firstname, string lastName)
{
if (_disabled)
{
throw new AggregateException("Can not add a friend to a disabled user.");
}
if (IDontHaveAnyFriends() || ThatIsANewFriend(userId))
{
ApplyChange(UserEvents.NewFriend(_id, friendsId, firstname, lastName));
}
}
public async Task <IActionResult> PostUserEvents([FromBody] UserEvents userEvents)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.UserEvents.Add(userEvents);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUserEvents", new { id = userEvents.UserEventId }, userEvents));
}
public void AddWishListItem(UserId id, WishListItemId wishlistItemId, RestaurantId restoId, string someNotes)
{
if (_disabled)
{
throw new AggregateException("Can not add a to the wish list of a disabled user.");
}
if (MyWishListIsEmpty() || ThatResturantIsNotInMyWishList(restoId))
{
ApplyChange(UserEvents.WishListItemAdded(id, wishlistItemId, restoId, someNotes));
}
}
void Awake()
{
Instance = this;
Input.multiTouchEnabled = false;
UserData = new UserData();
UserData.LoadAll();
UserEvents = new UserEvents();
Debug.Log("Application initialized");
}
public AuthorizationViewModel(IUserRelatedRepository repo, IUserSession userSession)
{
Repository = repo;
UserSession = userSession;
LoginCommand = RegisterCommandAction(
(obj) =>
{
#if DEBUG
AuthenticatedUser = Repository.FindUser("root");
InputtedPassword = "******";
#else
AuthenticatedUser = Repository.FindUser(InputtedLogin);
#endif
if (IsInputtedPasswordCorrect())
{
RelatedView.Hide();
UserEvents.RaiseOnUserLoggedIn(AuthenticatedUser);
UserSession.AuthorizeUser(
AuthenticatedUser,
UserRightsBuilder.GetUserRights(
UserSession.GetAccessLevel(AuthenticatedUser)
)
);
_mainView = new MainView();
_mainView.DataContext =
ResolveDependency <IMainViewModel>()
as MainViewModel;
_mainView.Show();
}
else
{
MessageToUser = "******";
}
}
);
UserEvents.OnUserLoggedOut += () =>
{
_mainView.Hide();
InputtedLogin = InputtedPassword = string.Empty;
RelatedView.Show();
};
}
public void CreatingNewUser()
{
var id = new UserId(Guid.NewGuid());
var email = "*****@*****.**";
var metroId = 11;
var command = new CreateBasicUser {
EmailAddress = email, GlobalPersonId = id.Gpid, MetroId = metroId
};
new ConstructorScenarioFor <User>(() => User.CreateBasicUser(id, email, metroId)).
Then(UserEvents.Created(email, id, metroId, false)).
Assert();
}
private void CheckIfUserIsDoneWithTest()
{
if (TheTestStats.TotalQuestions <= 0)
{
//calculate final score
float finalScore = (TheTestStats.QuestionsRight * 100 / (TheTestStats.QuestionsRight + TheTestStats.QuestionsWrong));
UserEvents.OnUserFinishedTheTest(this, new FinalScoreEventArgs()
{
FinalScore = finalScore
});
}
}
public void AddWishListItemToUser()
{
var id = new UserId(Guid.NewGuid());
var email = "*****@*****.**";
var metroId = 11;
var wishlistItemId = new WishListItemId(Guid.NewGuid());
var restoId = new RestaurantId(Guid.NewGuid());
new CommandScenarioFor <User>(User.Factory)
.Given(UserEvents.Created(email, id, metroId, false))
.When(user => user.AddWishListItem(id, wishlistItemId, restoId, "some notes"))
.Then(UserEvents.WishListItemAdded(id, wishlistItemId, restoId, "some notes"))
.Assert();
}
public void Initialize()
{
ModerationEvents.Register();
AchievementEvents.Register();
GroupEvents.Register();
CatalogEvents.Register();
CameraEvents.Register();
UserEvents.Register();
RoomEvents.Register();
LandingEvents.Register();
NavigatorEvents.Register();
CraftingEvents.Register();
GameCenterEvents.Register();
MiscEvents.Register();
}
public void AlreadyDisabledUserThrows()
{
// this test may be mute; disabling an already disabled user may be
// the result of some eventual consistency, and ignoring a second command
// to disable would make the operation idempotent
var id = new UserId(Guid.NewGuid());
var email = "*****@*****.**";
var metroId = 11;
new CommandScenarioFor <User>(User.Factory)
.Given(UserEvents.Created(email, id, metroId, false))
.Given(UserEvents.Disabled(id))
.When(user => user.Disable())
.Throws(new AggregateException(string.Format("User {0} is already disabled", id)))
.Assert();
}
private void NextButton_Click(object sender, RoutedEventArgs e)
{
//first read the user's answer
float userAnswer = float.Parse(AnswerTextBox.Text);
//then fire ov the event that te user answered a question
UserEvents.OnUserAnsweredQuestion(this, new AnswerEventArgs()
{
Answer = userAnswer
});
//reset the label and textbox and total questions
TotalQuestionsLabel.Content = TM.TheTestStats.TotalQuestions;
EquationLabel.Content = TM.TheTestStats.CurrentEquation.FullEquation;
AnswerTextBox.Clear();
}
public void AddFriendsToUser()
{
var id = new UserId(Guid.NewGuid());
var friendId = new UserId(Guid.NewGuid());
var email = "*****@*****.**";
var metroId = 11;
var fname = "John";
var lname = "Jack";
var command = new AddFriendToUser(id, friendId, fname, lname, null, null, null);
new CommandScenarioFor <User>(User.Factory)
.Given(UserEvents.Created(email, id, metroId, false))
.When(user => user.AddFriend(new UserId(command.Gpid), new UserId(command.FriendsGpid), command.FName, command.LName))
.Then(UserEvents.NewFriend(id, friendId, fname, lname))
.Assert();
}
//Get all user event data
public UserEventResult Get(UserEvents request)
{
return new UserEventResult { UserEvent = Db.Select<UserEvent>() };
}
