public void TryToAcceptTeacherInvitationWithAlreadyFoundTeacher_GetException()
{
//Arrange
var publisher = new Mock <IEventPublisher>();
var groupFacade = new GroupFacade(_groupRepository, _userRepository, _sanctionRepository,
new GroupSettings(1, 100, 0, 1000), publisher.Object);
var accountFacade = new AccountFacade(_keysRepository, _userRepository, _emailSender.Object,
userSettings);
var userFacade = new UserFacade(_userRepository, _groupRepository, _eventRepository, _publisher.Object);
var creatorId = accountFacade.RegUser("Creator", new Credentials("email1", "password"), false);
var teacherId = accountFacade.RegUser("Teacher", new Credentials("email2", "password"), true);
var newTeacherId = accountFacade.RegUser("Teacher", new Credentials("email3", "password"), true);
var createdGroupId = groupFacade.CreateGroup(creatorId, "Some group",
new List <string> {
"c#"
}, "Very interesting", 1, 100, false, GroupType.Lecture);
userFacade.Invite(creatorId, newTeacherId, createdGroupId, MemberRole.Teacher);
var invitation = userFacade.GetAllInvitationsForUser(newTeacherId).ToList()[0];
//Act
groupFacade.ApproveTeacher(teacherId, createdGroupId);
userFacade.ChangeInvitationStatus(newTeacherId, invitation.Id, InvitationStatus.Accepted);
}
public ActionResult AddObjectGroup(Int32 idObjeto)
{
Int32 idUsuarioLogado = AccountFacade.GetLoggedInUser().IdUsuario;
List <Grupo> gruposFilter = _context.Grupos.Where(g => g.IdObjeto == null &&
g.Usuarios.Any(u => u.IdUsuario == idUsuarioLogado)).OrderBy(g => g.NmGrupo).Decrypt();
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
Grupo grupoObj = null;
while (grupoObj == null)
{
grupoObj = _context.Grupos.Include(g => g.Usuarios).Include(g => g.Salt)
.Where(g => g.IdObjeto != null && g.IdObjeto == idObjeto).FirstOrDefault();
_context = new CoeusProjectContext();
}
gruposFilter.Add(grupoObj.Decrypt());
return(Json(gruposFilter.Select(s => new Grupo
{
IdGrupo = s.IdGrupo,
NmGrupo = s.NmGrupo
})));
}
public ActionResult Follow(Int32 idObjeto)
{
Objeto objeto = _context.Objetos.Where(o => o.IdObjeto == idObjeto).FirstOrDefault();
if (objeto == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden, "Objeto não encontrado"));
}
Usuario usuario = _context.Usuarios.Include(u => u.Seguidores).Where(u => u.IdUsuario == objeto.IdUsuario).FirstOrDefault();
if (usuario == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden, "Usuário não encontrado"));
}
if (usuario.Seguidores == null)
{
usuario.Seguidores = new List <Usuario>();
}
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
if (usuario.Seguidores.Where(s => s.IdUsuario == usuarioLogado.IdUsuario).Count() > 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden, "Você já segue essa pessoa"));
}
usuario.Seguidores.Add(_context.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault());
_context.Entry(usuario).State = EntityState.Modified;
_context.SaveChanges();
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public ActionResult EditPartial(Int32 idVideo)
{
Video video = _context.Videos.Where(v => v.IdVideo == idVideo).Include(v => v.Objeto).FirstOrDefault();
if (video == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, "Vídeo não encontrado"));
}
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
if (video.Objeto.IdUsuario != usuarioLogado.IdUsuario)
{
video.Objeto.QtAcessos++;
_context.Entry(video).State = EntityState.Modified;
_context.SaveChanges();
Int32 noAvUsuario = 0;
Avaliacao usuarioAvaliacao = video.Objeto.Avaliacoes.Where(a => a.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault();
if (usuarioAvaliacao != null)
{
noAvUsuario = usuarioAvaliacao.NoAvaliacao;
}
ViewBag.noAvUsuario = noAvUsuario;
}
video.Decrypt();
return(View("_VideoWatchPartial", video));
}
public void TryToInviteTeacherToGroupWithApprovedTeacher_GetException()
{
//Arrange
var publisher = new Mock <IEventPublisher>();
var groupFacade = new GroupFacade(_groupRepository, _userRepository, _sanctionRepository,
new GroupSettings(1, 100, 0, 1000), publisher.Object);
var accountFacade = new AccountFacade(_keysRepository,
_userRepository, _emailSender.Object, userSettings);
var userFacade = new UserFacade(_userRepository, _groupRepository, _eventRepository, _publisher.Object);
var creatorId = accountFacade.RegUser("Creator", new Credentials("email1", "password"), false);
var teacherId = accountFacade.RegUser("Teacher", new Credentials("email2", "password"), true);
var anotherTeacherId =
accountFacade.RegUser("Another teacher", new Credentials("email3", "password"), true);
var createdGroupId = groupFacade.CreateGroup(creatorId, "Some group", new List <string> {
"c#"
},
"Very interesting", 1, 100, false, GroupType.Lecture);
var createdGroup = groupFacade.GetGroup(createdGroupId, creatorId);
groupFacade.ApproveTeacher(userFacade.GetUser(teacherId).Id, createdGroupId);
//Act
userFacade.Invite(creatorId, anotherTeacherId, createdGroupId, MemberRole.Teacher);
}
public async Task <ActionResult> Register(AccountCreateDTO accountCreateDto)
{
try
{
await AccountFacade.RegisterAccount(accountCreateDto);
//FormsAuthentication.SetAuthCookie(userCreateDto.Username, false);
var authTicket = new FormsAuthenticationTicket(1, accountCreateDto.Email, DateTime.Now,
DateTime.Now.AddMinutes(30), false, "");
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
HttpContext.Response.Cookies.Add(authCookie);
return(RedirectToAction("Index", "Home"));
}
catch (ArgumentException)
{
ModelState.AddModelError("Email Address", "Account with that email address already exists!");
return(View());
}
catch (DbEntityValidationException)
{
return(View());
}
catch (SqlException)
{
return(View());
}
}
public ActionResult EditPartial(Int32 idArtigo)
{
Artigo artigo = _context.Artigos.Where(a => a.IdArtigo == idArtigo).FirstOrDefault();
if (artigo == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, "Artigo não encontrado"));
}
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
if (artigo.Objeto.IdUsuario != usuarioLogado.IdUsuario)
{
artigo.Objeto.QtAcessos++;
_context.Entry(artigo).State = EntityState.Modified;
_context.SaveChanges();
Int32 noAvUsuario = 0;
Avaliacao usuarioAvaliacao = artigo.Objeto.Avaliacoes.Where(a => a.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault();
if (usuarioAvaliacao != null)
{
noAvUsuario = usuarioAvaliacao.NoAvaliacao;
}
ViewBag.noAvUsuario = noAvUsuario;
}
artigo.Decrypt();
return(View("_ArtigoEditPartial", artigo));
}
public ActionResult EditPartial()
{
Usuario usuario = AccountFacade.GetLoggedInUser();
usuario.PwUsuario = String.Empty;
return(View("_EditPartial", usuario));
}
public void TryToInviteUserWithTeacherFlag_IsItPossible()
{
//Arrange
var publisher = new Mock <IEventPublisher>();
var groupFacade = new GroupFacade(_groupRepository, _userRepository, _sanctionRepository,
new GroupSettings(1, 100, 0, 1000), publisher.Object);
var accountFacade = new AccountFacade(_keysRepository,
_userRepository, _emailSender.Object, userSettings);
var userFacade = new UserFacade(_userRepository, _groupRepository, _eventRepository, _publisher.Object);
var creatorId =
accountFacade.RegUser("Creator", new Credentials("email1", "password"), false);
var teacherId =
accountFacade.RegUser("Teacher", new Credentials("email2", "password"), true);
var createdGroupId = groupFacade.CreateGroup(creatorId, "Some group",
new List <string> {
"c#"
}, "Very interesting", 1, 100, false, GroupType.Lecture);
//Act
userFacade.Invite(creatorId, teacherId, createdGroupId, MemberRole.Teacher);
var invitations = userFacade.GetAllInvitationsForUser(teacherId).ToList();
//Assert
Assert.AreEqual(createdGroupId, invitations[0].ToGroup);
}
public void Initialize()
{
var emailSender = new Mock <IEmailSender>();
var keysRepository = new InMemoryKeysRepository();
var eventRepository = new InMemoryEventRepository();
var groupRepository = new InMemoryGroupRepository();
_userRepository = new InMemoryUserRepository();
var fileRepository = new InMemoryFileRepository();
_sanctionRepository = new InMemorySanctionRepository();
var userSettings = new UserSettings("");
var adminKey = new Key("adminEmail", KeyAppointment.BecomeModerator);
keysRepository.AddKey(adminKey);
var accountFacade = new AccountFacade(keysRepository, _userRepository, emailSender.Object, userSettings);
_publisher = new Mock <IEventPublisher>();
_userEditFacade = new UserEditFacade(_userRepository, fileRepository, _sanctionRepository);
_userFacade = new UserFacade(_userRepository, groupRepository, eventRepository, _publisher.Object);
_adminId = accountFacade.RegUser("admin", Credentials.FromRawData("adminEmail", "password"), false,
adminKey.Value);
_testUserId = accountFacade.RegUser("Ivan", Credentials.FromRawData("*****@*****.**", "1"), false);
}
public void AcceptUserInvitation_GetAddedUserToGroup()
{
//Arrange
var publisher = new Mock <IEventPublisher>();
var groupFacade = new GroupFacade(_groupRepository, _userRepository, _sanctionRepository,
new GroupSettings(1, 100, 0, 1000), publisher.Object);
var accountFacade = new AccountFacade(_keysRepository, _userRepository, _emailSender.Object,
userSettings);
var userFacade = new UserFacade(_userRepository, _groupRepository, _eventRepository, _publisher.Object);
var creatorId = accountFacade.RegUser("Creator", new Credentials("email1", "password"), false);
var invitedId = accountFacade.RegUser("Teacher", new Credentials("email2", "password"), true);
var createdGroupId = groupFacade.CreateGroup(creatorId, "Some group",
new List <string> {
"c#"
}, "Very interesting", 3, 100, false, GroupType.Lecture);
userFacade.Invite(creatorId, invitedId, createdGroupId, MemberRole.Member);
var invitation = userFacade.GetAllInvitationsForUser(invitedId).ToList()[0];
//Act
userFacade.ChangeInvitationStatus(invitedId, invitation.Id, InvitationStatus.Accepted);
//Assert
var createdGroup = _groupRepository.GetGroupById(createdGroupId);
Assert.AreEqual(2, createdGroup.Members.Count);
}
public async Task <ActionResult> Login(LoginModel model, string returnUrl)
{
(bool success, bool isAdministrator) = await AccountFacade.Login(model.EmailAddress, model.Password);
if (success)
{
//FormsAuthentication.SetAuthCookie(model.Username, false);
var authTicket = new FormsAuthenticationTicket(1, model.EmailAddress, DateTime.Now,
DateTime.Now.AddMinutes(30), false, isAdministrator.ToString());
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
HttpContext.Response.Cookies.Add(authCookie);
var decodedUrl = "";
if (!string.IsNullOrEmpty(returnUrl))
{
decodedUrl = Server.UrlDecode(returnUrl);
}
if (Url.IsLocalUrl(decodedUrl))
{
return(Redirect(decodedUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Wrong email address or password!");
return(View());
}
public async Task <ActionResult> ChangeEmail(ChangeEmailModel model)
{
if (model.NewEmail == null || model.NewEmailAgain == null)
{
return(View(model));
}
if (model.NewEmail == model.NewEmailAgain)
{
var account = await AccountFacade.GetAccountAccordingToEmailAsync(model.Email);
if ((await AccountFacade.GetAccountAccordingToEmailAsync(model.NewEmail)) != null)
{
ModelState.AddModelError("", "Account with this Email already exist");
return(View(new ChangeEmailModel {
Email = model.Email
}));
}
account.Email = model.NewEmail;
var result = await AccountFacade.EditAccountAsync(account);
return(await Login(new LoginModel { EmailAddress = model.NewEmail, Password = account.Password }, null));
}
ModelState.AddModelError("", "Entered Emails aren't same");
return(View(new ChangeEmailModel {
Email = model.Email
}));
}
public async Task <ActionResult> Details(string email)
{
var account = await AccountFacade.GetAccountAccordingToEmailAsync(email);
var myAuctions = (await AuctionFacade.GetAllAuctionsForAccount(account.Id)).ToList();
var allMyBids = (await AccountFacade.GetAllBidsAccordingToAccount(account.Id)).ToList();
var biddedAuctions = new List <AuctionDTO>();
foreach (var auction in allMyBids)
{
biddedAuctions.Add(await AuctionFacade.GetAuctionAsync(auction.AuctionId));
}
biddedAuctions = biddedAuctions.Distinct().ToList();
var biddedAuctionsLastBidAccount = new List <Pair <AuctionDTO, AccountDTO> >();
foreach (var auction in biddedAuctions)
{
biddedAuctionsLastBidAccount.Add(new Pair <AuctionDTO, AccountDTO>(auction, await AccountFacade.GetAccountAccordingToIdAsync(
(await AuctionFacade.GetAllBidsAccordingToAuction(auction.Id)).OrderByDescending(x => x.BidDateTime)
.First().AccountId)));
}
AccountDetailModel accountDetailModel = new AccountDetailModel
{
AccountDto = account,
MyAuctions = myAuctions,
BiddingAuctionsAndLastBid = new List <Pair <AuctionDTO, AccountDTO> >(biddedAuctionsLastBidAccount)
};
return(View("AccountDeatilView", accountDetailModel));
}
public ActionResult Delete(DataSourceRequest request, Artigo artigo)
{
Artigo artigoDel = _context.Artigos.Where(a => a.IdArtigo == artigo.IdArtigo).FirstOrDefault();
if (artigoDel == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden, "Artigo não encontrado"));
}
Objeto objeto = _context.Objetos.Include(o => o.Temas).Where(o => o.IdObjeto == artigoDel.IdObjeto).FirstOrDefault();
if (objeto.Temas != null)
{
objeto.Temas.Clear();
}
Grupo grupo = _context.Grupos.Include(g => g.Usuarios).Where(g => g.IdObjeto != null && g.IdObjeto == objeto.IdObjeto).FirstOrDefault();
if (grupo != null)
{
if (grupo.Usuarios != null)
{
grupo.Usuarios.Clear();
}
_context.Grupos.Remove(grupo);
}
_context.Artigos.Remove(artigoDel);
_context.Objetos.Remove(objeto);
_context.SaveChanges();
return(GetArtigos(request, AccountFacade.GetLoggedInUser().IdUsuario));
}
public ActionResult Avaliacao(Int32 idArtigo, Int32 noAvaliacao)
{
Artigo artigo = _context.Artigos.Where(a => a.IdArtigo == idArtigo).Include(a => a.Objeto).FirstOrDefault();
if (artigo == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
Objeto objeto = artigo.Objeto;
if (objeto.Avaliacoes == null)
{
objeto.Avaliacoes = new List <Avaliacao>();
}
Usuario usuarioLogado = AccountFacade.GetLoggedInUser().Encrypt();
Avaliacao avaliacao = objeto.Avaliacoes.Where(a => a.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault();
if (avaliacao == null)
{
objeto.Avaliacoes.Add(new Avaliacao {
IdUsuario = usuarioLogado.IdUsuario, NoAvaliacao = noAvaliacao
});
}
else
{
avaliacao.NoAvaliacao = noAvaliacao;
_context.Entry(avaliacao).State = EntityState.Modified;
}
_context.SaveChanges();
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public async Task <ActionResult> CreateBid(AuctionDetailViewModel auctionModel)
{
var accountDto = await AccountFacade.GetAccountAccordingToEmailAsync(auctionModel.EmailOfBidAccount);
var result = await AuctionFacade.BidOnAuctionAsync(auctionModel.Id, accountDto.Id, auctionModel.NewBidValue);
return(await Details(auctionModel.Id));
}
public async Task <ActionResult> AccountDetail(Guid id)
{
var result = await AccountFacade.GetAccountAccordingToIdAsync(id);
var model = await InitializeAccountEditModel(result);
return(View("AccountEdit", model));
}
public async Task <ActionResult> AccountList()
{
var allAccounts = await AccountFacade.GetAllAccountsAsync();
var model = await InitializeAccountListModel(allAccounts.Items.OrderBy(x => x.FirstName).ToList());
return(View(model));
}
public ActionResult Create(String nmObjeto, String txDescricao, String txArtigo, List <InteresseVM> tags)
{
try
{
if (tags == null || tags.Count == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, "É necessário selecionar ao menos 1 tema para o artigo"));
}
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
List <Objeto> objetos = (new CoeusProjectContext()).Objetos.Where(o => o.IdUsuario == usuarioLogado.IdUsuario).Decrypt();
if (objetos.Where(o => o.NmObjeto == nmObjeto).Count() > 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
Artigo artigo = new Artigo()
{
Objeto = new Objeto()
{
IdUsuario = usuarioLogado.IdUsuario,
Salt = Salt.GetSalt(),
NmObjeto = nmObjeto,
TxDescricao = txDescricao
},
TxArtigo = txArtigo
};
artigo.Objeto.Temas = new List <Tema>();
foreach (InteresseVM interesse in tags)
{
artigo.Objeto.Temas.Add(_context.Temas.Where(t => t.NmTema == interesse.NmInteresse).FirstOrDefault());
}
_context.Artigos.Add(artigo.Encrypt(_context));
Grupo artigoGrupo = new Grupo()
{
IdObjeto = artigo.IdObjeto,
Salt = Salt.GetSalt(),
Usuarios = new List <Usuario> {
_context.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault()
},
NmGrupo = nmObjeto
};
_context.Grupos.Add(artigoGrupo.Encrypt(_context));
_context.SaveChanges();
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
}
}
/// <summary>
/// Constructor for AccountSettingsController
/// </summary>
/// <param name="balanceFacade"></param>
/// <param name="currentAccountProvider"></param>
/// <param name="mapper"></param>
/// <param name="accountFacade"></param>
public AccountSettingsController(
BalanceFacade balanceFacade,
ICurrentAccountProvider currentAccountProvider,
Mapper mapper,
AccountFacade accountFacade) : base(currentAccountProvider, mapper)
{
_balanceFacade = balanceFacade;
_accountFacade = accountFacade;
}
public void Join()
{
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
foreach (Grupo grupo in usuarioLogado.Grupos)
{
Groups.Add(Context.ConnectionId, grupo.IdGrupo.ToString());
}
}
public ActionResult Edit(Int32 idGrupo, String nmGrupo, List <Usuario> usuarios)
{
try
{
Grupo grupo = _context.Grupos.Where(g => g.IdGrupo == idGrupo).Include(g => g.Usuarios).FirstOrDefault().Decrypt();
if (grupo == null)
{
throw new Exception("Grupo inexistente");
}
List <Usuario> usuariosGrupo = grupo.Usuarios.ToList();
if (String.IsNullOrEmpty(nmGrupo))
{
throw new Exception("Nome inválido para o grupo");
}
if (usuarios == null || usuarios.Count() == 0)
{
throw new Exception("É necessário selecionar algum usuário para o grupo");
}
grupo.NmGrupo = nmGrupo;
for (int i = usuariosGrupo.Count() - 1; i >= 0; i--)
{
if (usuarios.Where(u => u.IdUsuario == usuariosGrupo[i].IdUsuario).Count() == 0)
{
grupo.Usuarios.Remove(usuariosGrupo[i]);
}
}
for (int i = usuarios.Count() - 1; i >= 0; i--)
{
if (usuariosGrupo.Where(ug => ug.IdUsuario == usuarios[i].IdUsuario).Count() == 0)
{
Int32 idUsuarioAdded = usuarios[i].IdUsuario;
grupo.Usuarios.Add(_context.Usuarios.Where(u => u.IdUsuario == idUsuarioAdded).FirstOrDefault());
}
}
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
if (grupo.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).Count() == 0)
{
grupo.Usuarios.Add(_context.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault());
}
grupo.Encrypt();
_context.Entry(grupo).State = EntityState.Modified;
_context.SaveChanges();
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable, ErrorFacade.GetErrorMessage(ex)));
}
}
public async Task <ActionResult> Logout()
{
var account = await AccountFacade.GetAccountAccordingToEmailAsync(User.Identity.Name);
//Response.ClearAllShoppingCartItems(customer.Username);
//OrderFacade.ReleaseReservations(customer.Id);
FormsAuthentication.SignOut();
return(RedirectToAction("Index", "Home"));
}
public void TryToRegUserWithExistingEmail_GetException()
{
//Arrange
var accountFacade = new AccountFacade(_keysRepository,
_userRepository, _emailSender.Object, userSettings);
var userFacade = new UserFacade(_userRepository, _groupRepository, _eventRepository, _publisher.Object);
//Act
accountFacade.RegUser("Grisha", new Credentials("*****@*****.**", "password1"), true);
accountFacade.RegUser("Sasha", new Credentials("*****@*****.**", "password2"), false);
}
public ActionResult CreatePartial()
{
Artigo artigo = new Artigo()
{
Objeto = new Objeto()
{
IdUsuario = AccountFacade.GetLoggedInUser().IdUsuario
}
};
return(View("_ArtigoEditPartial", artigo));
}
public void JoinObjectChat(Int32 idObject = 0)
{
Boolean changed = false;
CoeusProjectContext context = new CoeusProjectContext();
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
IQueryable <Grupo> userObjectGroup = context.Grupos.Where(g => g.IdObjeto != null && g.Usuarios.Any(u => u.IdUsuario == usuarioLogado.IdUsuario));
List <Grupo> gruposList = userObjectGroup.ToList();
foreach (Grupo grupo in userObjectGroup)
{
Groups.Remove(Context.ConnectionId, grupo.IdGrupo.ToString());
}
Objeto objeto = context.Objetos.Where(o => o.IdObjeto == idObject).Include(o => o.Salt).FirstOrDefault().Decrypt();
Grupo grupoObj = context.Grupos.Include(g => g.Usuarios).Where(g => g.IdObjeto != null && g.IdObjeto == idObject).FirstOrDefault();
if (grupoObj == null)
{
changed = true;
grupoObj = new Grupo()
{
IdObjeto = idObject,
Salt = Salt.GetSalt(),
NmGrupo = objeto.NmObjeto
};
context.Grupos.Add(grupoObj.Encrypt());
}
if (grupoObj.Usuarios == null)
{
grupoObj.Usuarios = new List <Usuario>();
}
if (grupoObj.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).Count() == 0)
{
changed = true;
grupoObj.Usuarios.Add(context.Usuarios.Where(u => u.IdUsuario == usuarioLogado.IdUsuario).FirstOrDefault());
}
if (changed)
{
objeto.Encrypt();
context.Entry(objeto).State = EntityState.Modified;
context.SaveChanges();
}
Groups.Add(Context.ConnectionId, grupoObj.IdGrupo.ToString());
}
public void RegistrateAdminUsingWrongTypeKey_GetException()
{
//Arrange
var accountFacade = new AccountFacade(_keysRepository, _userRepository, _emailSender.Object, userSettings);
var userFacade = new UserFacade(_userRepository, _groupRepository, _eventRepository, _publisher.Object);
var key = new Key("email", KeyAppointment.ChangePassword);
_keysRepository.AddKey(key);
//Act
var userId = accountFacade.RegUser("Alena", Credentials.FromRawData("email", "password"), true, key.Value);
}
public ActionResult Login()
{
(new FileController()).CleanImages(_context);
Usuario usuarioLogado = AccountFacade.GetLoggedInUser();
if (usuarioLogado != null)
{
//return View("Home/Index");
return(RedirectToAction("Index", "Home"));
}
return(View());
}
public void RegAdminWithEmailThatDoesntEqualExpectedEmail_GetException()
{
//Arrange
var accountFacade = new AccountFacade(_keysRepository, _userRepository, _emailSender.Object, userSettings);
var userFacade = new UserFacade(_userRepository, _groupRepository, _eventRepository, _publisher.Object);
var key = new Key("expectedEmail", KeyAppointment.BecomeAdmin);
_keysRepository.AddKey(key);
//Act
var userId = accountFacade.RegUser("Alena", Credentials.FromRawData("anotherEmail", "password"), true,
key.Value);
}
