/// <summary>
/// Maps the user information to the identity.
/// </summary>
/// <param name="userInformation"></param>
/// <param name="identity"></param>
public void MapUserInformationToIdentity(Dictionary<string, object> userInformation, MyEventsIdentity identity)
{
identity.UserName = ConfigurationManager.AppSettings["fakeUserName"];
identity.UserId = int.Parse(ConfigurationManager.AppSettings["fakeUserId"]);
identity.ThirdPartyUserId = ConfigurationManager.AppSettings["fakeFacebookUserId"];
identity.Email = "*****@*****.**";
}
public ActionResult Delete(MyEventsIdentity identity, int sessionId, int eventDefinitionId)
{
_authorizationService.ValidateSessionAuthorization(identity, sessionId);
_sessionRepository.Delete(sessionId);
return RedirectToAction("Manage", new { eventDefinitionId = eventDefinitionId });
}
/// <summary>
/// Creates the user authentication ticket.
/// </summary>
/// <param name="identity"></param>
/// <param name="httpContext"></param>
public void CreateAuthenticationTicket(MyEventsIdentity identity, HttpContextBase httpContext)
{
Dictionary<string, object> facebookUserInformation = _thirdPartyLoginService.GetUserInformation(identity);
_thirdPartyLoginService.MapUserInformationToIdentity(facebookUserInformation, identity);
identity.UserId = AddUser(identity);
var serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(identity);
var authTicket =
new FormsAuthenticationTicket(
3,
identity.UserName,
DateTime.Now,
DateTime.Now.AddMinutes(FormsAuthentication.Timeout.TotalMinutes),
false,
userData
);
var authCookie = new HttpCookie(
FormsAuthentication.FormsCookieName,
FormsAuthentication.Encrypt(authTicket)
)
{
HttpOnly = true
};
httpContext.Response.AppendCookie(authCookie);
}
/// <summary>
/// Obtains the user information for the connected user.
/// </summary>
/// <param name="identity"></param>
/// <returns></returns>
public Dictionary<string, object> GetUserInformation(MyEventsIdentity identity)
{
var userInformation = new Dictionary<string, object>();
userInformation.Add("name", ConfigurationManager.AppSettings["fakeUserName"]);
userInformation.Add("id", ConfigurationManager.AppSettings["fakeFacebookUserId"]);
return userInformation;
}
/// <summary>
/// Detail view action
/// </summary>
/// <param name="identity"></param>
/// <param name="eventDefinitionId"></param>
/// <returns></returns>
public ActionResult Detail(MyEventsIdentity identity, int eventDefinitionId)
{
var eventDefinition = _eventsRepository.GetById(eventDefinitionId);
if (null == eventDefinition)
throw new HttpException("404");
return View(eventDefinition);
}
public ActionResult DeleteMaterial(MyEventsIdentity identity, int materialId)
{
var material = _materialRepository.Get(materialId);
int sessionId = material.SessionId;
_authorizationService.ValidateSessionAuthorization(identity, sessionId);
_materialRepository.Delete(materialId);
return RedirectToAction("Materials", new { sessionId = sessionId });
}
/// <summary>
/// Index action.
/// </summary>
/// <param name="identity"></param>
/// <returns></returns>
public ActionResult Index(MyEventsIdentity identity)
{
IEnumerable<EventDefinition> events = _eventDefinitionRepository.GetByOrganizerId(identity.UserId, string.Empty, int.MaxValue, 0, true);
var homeViewModel = new HomeViewModel
{
Events = events
};
return View(homeViewModel);
}
public ActionResult GetSheduleInfo(MyEventsIdentity identity, int eventDefinitionId)
{
var eventDefinition = _eventDefinitionRepository.GetById(eventDefinitionId);
_authorizationService.ValidateEventAuthorization(identity, eventDefinition);
var mapper = new EventDefinitionToScheduleViewModelMapper();
var viewModel = mapper.Map(eventDefinition);
return Json(viewModel, JsonRequestBehavior.AllowGet);
}
public void UpdateSession(MyEventsIdentity identity, int sessionId, DateTime startTime, int duration, int roomNumber)
{
var session = _sessionRepository.Get(sessionId);
_authorizationService.ValidateSessionAuthorization(identity, session);
session.StartTime = startTime;
session.Duration = duration;
session.RoomNumber = roomNumber;
_sessionRepository.Update(session);
}
/// <summary>
/// Index action.
/// </summary>
/// <param name="eventDefinitionId"></param>
/// <param name="identity"></param>
/// <returns></returns>
public ActionResult Index(MyEventsIdentity identity, int eventDefinitionId)
{
var eventDefinition = this._eventDefinitionRepository.GetById(eventDefinitionId);
ValidateEventAuthorization(identity, eventDefinition);
RegisteredUsersViewModel vm = new RegisteredUsersViewModel()
{
RegisteredUsers = this._registeredUserRepository.GetAllByEventId(eventDefinitionId),
Likes = eventDefinition.Likes
};
return View(vm);
}
public ActionResult Create(MyEventsIdentity identity, EditEventViewModel viewModel)
{
SetLogo(viewModel, ModelState);
if (!ModelState.IsValid)
return View(viewModel);
var eventDefinition = new EventDefinition();
MapViewModelToEventDefinition(viewModel, eventDefinition);
eventDefinition.OrganizerId = identity.UserId;
_eventsRepository.Add(eventDefinition);
ResetLogo();
return RedirectToAction("Index", "Home");
}
public ActionResult UploadMaterial(MyEventsIdentity identity, int sessionId)
{
if (Request.Files != null && Request.Files.Count > 0)
{
HttpPostedFileBase file = Request.Files[0];
var fileBytes = new byte[file.ContentLength];
file.InputStream.Read(fileBytes, 0, (int)file.ContentLength);
if (fileBytes.Length != 0)
{
_authorizationService.ValidateSessionAuthorization(identity, sessionId);
var material = new Material
{
SessionId = sessionId,
Name = HttpUtility.HtmlDecode(file.FileName),
ContentType = file.ContentType,
Content = fileBytes
};
_materialRepository.Add(material);
return PartialView("MaterialRow", material);
}
}
return null;
}
public ActionResult Save(MyEventsIdentity identity, Session session)
{
if (!ModelState.IsValid)
return PartialView("Form", session);
_authorizationService.ValidateSessionAuthorization(identity, session);
SaveSession(session);
return RedirectToAction("Manage", new { eventDefinitionId = session.EventDefinitionId });
}
/// <summary>
/// Manage action.
/// </summary>
/// <param name="identity"></param>
/// <param name="eventDefinitionId"></param>
/// <returns></returns>
public ActionResult Manage(MyEventsIdentity identity, int eventDefinitionId)
{
var sessions = _sessionRepository.GetAll(eventDefinitionId);
var viewModel = new ManageSessionViewModel()
{
EventDefinitonId = eventDefinitionId,
Sessions = sessions
};
return View(viewModel);
}
/// <summary>
/// Edit action.
/// </summary>
/// <param name="identity"></param>
/// <param name="sessionId"></param>
/// <returns></returns>
public ActionResult Edit(MyEventsIdentity identity, int sessionId)
{
var session = _sessionRepository.Get(sessionId);
_authorizationService.ValidateSessionAuthorization(identity, session);
return View("Form", session);
}
/// <summary>
/// Maps the user information to the identity.
/// </summary>
/// <param name="userInformation"></param>
/// <param name="identity"></param>
public void MapUserInformationToIdentity(Dictionary<string, object> userInformation, MyEventsIdentity identity)
{
var mapper = new FacebookUserInformationToIdentityMapper();
mapper.Map(userInformation, identity);
}
/// <summary>
/// Logs out the current user.
/// </summary>
/// <param name="identity"></param>
public void LogOut(MyEventsIdentity identity)
{
if (null == identity)
return;
var client = new WebClient();
string facebookLogOutUrl = string.Format("https://www.facebook.com/logout.php?access_token={0}", identity.AccessToken);
client.DownloadString(facebookLogOutUrl);
}
/// <summary>
/// Log Out action.
/// </summary>
/// <returns></returns>
public ActionResult LogOut(MyEventsIdentity identity)
{
_authenticationService.DestroyAuthenticationTicket(identity);
return RedirectToAction("Index", "Home");
}
/// <summary>
/// Validates the event authorization.
/// </summary>
/// <param name="identity">The identity.</param>
/// <param name="eventDefinitionid">The event definitionid.</param>
public void ValidateEventAuthorization(MyEventsIdentity identity, int eventDefinitionid)
{
var eventDefinition = _eventDefinitionRepository.GetById(eventDefinitionid);
ValidateEventAuthorization(identity, eventDefinition);
}
/// <summary>
/// Validates the session authorization.
/// </summary>
/// <param name="identity">The identity.</param>
/// <param name="sessionId">The session id.</param>
public void ValidateSessionAuthorization(MyEventsIdentity identity, int sessionId)
{
var session = _sessionRepository.Get(sessionId);
ValidateEventAuthorization(identity, session.EventDefinitionId);
}
/// <summary>
/// Validates the session authorization.
/// </summary>
/// <param name="identity">The identity.</param>
/// <param name="session">The session.</param>
/// <exception cref="System.UnauthorizedAccessException"></exception>
public void ValidateSessionAuthorization(MyEventsIdentity identity, Session session)
{
var eventDefinition = _eventDefinitionRepository.GetById(session.EventDefinitionId);
if (identity.UserId != eventDefinition.OrganizerId)
throw new UnauthorizedAccessException();
}
/// <summary>
/// Destroys the authentication ticket.
/// </summary>
public void DestroyAuthenticationTicket(MyEventsIdentity identity)
{
_thirdPartyLoginService.LogOut(identity);
FormsAuthentication.SignOut();
}
/// <summary>
/// Logs out the current user.
/// </summary>
/// <param name="identity"></param>
public void LogOut(MyEventsIdentity identity)
{
}
/// <summary>
/// Obtains the user information for the connected user.
/// </summary>
/// <param name="identity"></param>
/// <returns></returns>
public Dictionary<string, object> GetUserInformation(MyEventsIdentity identity)
{
var client = new WebClient();
string meUrl = string.Format("https://graph.facebook.com/me?access_token={0}", identity.AccessToken);
string userInformationAsJson;
try
{
userInformationAsJson = client.DownloadString(meUrl);
}
catch (Exception)
{
return null;
}
var jsSerializer = new JavaScriptSerializer();
var userInformation = jsSerializer.Deserialize<Dictionary<string, object>>(userInformationAsJson);
return userInformation;
}
public ActionResult Delete(MyEventsIdentity identity, int eventDefinitionId)
{
EventDefinition eventDefinition = _eventsRepository.GetById(eventDefinitionId);
_authorizationService.ValidateEventAuthorization(identity, eventDefinition);
_eventsRepository.Delete(eventDefinitionId);
return RedirectToAction("Index", "Home");
}
private int AddUser(MyEventsIdentity identity)
{
var user = new RegisteredUser()
{
Email = identity.Email,
FacebookId = identity.ThirdPartyUserId,
Name = identity.UserName,
Bio = identity.Bio,
City = identity.City
};
int registeredUserId = _registeredUserRepository.Add(user);
return registeredUserId;
}
public ActionResult Edit(MyEventsIdentity identity, int eventDefinitionId)
{
EventDefinition eventDefinition = _eventsRepository.GetById(eventDefinitionId);
_authorizationService.ValidateEventAuthorization(identity, eventDefinition);
var viewModel = new EditEventViewModel()
{
HasLogo = true
};
MapEventDefinitionToViewModel(eventDefinition, viewModel);
ResetLogo();
return View(viewModel);
}
public ActionResult Edit(MyEventsIdentity identity, EditEventViewModel viewModel)
{
SetLogo(viewModel, ModelState);
if (!ModelState.IsValid)
return View(viewModel);
var eventDefinition = _eventsRepository.GetById(viewModel.EventDefinitionId);
_authorizationService.ValidateEventAuthorization(identity, eventDefinition);
MapViewModelToEventDefinition(viewModel, eventDefinition);
_eventsRepository.Update(eventDefinition);
ResetLogo();
return RedirectToAction("Index", "Home");
}
private void ValidateEventAuthorization(MyEventsIdentity identity, EventDefinition eventDefinition)
{
if (identity.UserId != eventDefinition.OrganizerId)
throw new UnauthorizedAccessException();
}
public ActionResult Register(MyEventsIdentity identity, int eventDefinitionId)
{
_registeredUserRepository.AddRegisteredUserToEvent(identity.UserId, eventDefinitionId);
return RedirectToAction("Detail", new { eventDefinitionId = eventDefinitionId });
}
