public ActionResult FreeLink(string projectUrl)
{
SafeAdmission valid = ((List <SafeAdmission>)Session["admissions"]).Where(x => x.projectUrl == projectUrl).First();
if (valid != null && valid.AccessType == (Int32)DbEnum.PollAccess.FreeLink)
{
HttpCookie cookie = Request.Cookies[MemberWorker.GetAnonymousCookieName()];
if (cookie == null)
{
Response.SetCookie(MemberWorker.SetAnonymousCookie());
return(RedirectToAction("Index", "Poll", new { poll = valid.projectUrl }));
}
else
{
var cookieData = cookie["Data"];
var project = Db.Context.Projects
.Join(Db.Context.ProjectAccessVoters, p => p.Id, pav => pav.ProjectId, (p, pav) => new { p, pav })
.Join(Db.Context.UserSets, z => z.pav.UserSetId, c => c.Id, (z, c) => new { z, c })
.Where(x => x.c.CookieValue.Equals(cookieData))
.Where(x => x.z.p.UrlCode.Equals(valid.projectUrl))
.Select(x => new { x.z.pav.Id })
.FirstOrDefault();
if (project == null)
{
valid.Status = true;
return(RedirectToAction("Index", "Poll", new { poll = valid.projectUrl }));
}
}
}
return(RedirectToAction("/", "Home"));
}
public ActionResult ValidateUser(string email, string pass, string projectUrl)
{
SafeAdmission valid = ((List <SafeAdmission>)Session["admissions"]).Where(x => x.projectUrl == projectUrl).First();
if (valid != null && valid.AccessType == (Int32)DbEnum.PollAccess.UserSet)
{
var project = Db.Context.Projects
.Join(Db.Context.ProjectAccessVoters, p => p.Id, pav => pav.ProjectId, (p, pav) => new { p, pav })
.Join(Db.Context.UserSets, z => z.pav.UserSetId, c => c.Id, (z, c) => new { z, c })
.Join(Db.Context.Users, u => u.c.UserId, s => s.Id, (z, c) => new { z, c })
.Where(x => x.c.Email.Equals(email))
.Where(x => x.z.z.p.UrlCode.Equals(valid.projectUrl))
.Select(x => new { UserSetId = x.z.z.pav.Id, User = x.c })
.FirstOrDefault();
if (project != null)
{
var hasUser = MemberWorker.SignIn(email, pass);
if (hasUser == MemberWorker.LoginStatus.Success)
{
valid.UserIdentity = project.UserSetId;
valid.Status = true;
return(RedirectToAction("Index", "Poll", new { poll = valid.projectUrl }));
}
}
}
return(Redirect("/"));
}
public async Task <bool> Delete(ObjectId memberId)
{
var response = await MemberWorker.DeleteMember(memberId);
await _redisCache.Del($"Member:{memberId}");
return(response);
}
public async Task <long> DeleteMembersByRoomId(ObjectId roomId)
{
(await MemberWorker.GetMembersByRoomId(roomId))
.Select(async member =>
await _redisCache.Del($"Member:{member.Id}"));
return(await MemberWorker.DeleteMembersByRoomId(roomId));
}
public ActionResult SignUp(String firstName, String lastName, String email, String pass)
{
try
{
var result = MemberWorker.SignUp(pass, email, firstName, lastName);
switch (result)
{
case MemberWorker.RegisterStatus.Success:
{
MemberWorker.AddUserCookie(Response, email, 3600);
return(new JsonResult()
{
Data = "Registration completed successfully"
});
}
case MemberWorker.RegisterStatus.NotValid:
return(new JsonResult()
{
Data = "Password or login you've entered is invalid"
});
case MemberWorker.RegisterStatus.EmailExists:
return(new JsonResult()
{
Data = "User with this email already exist"
});
default:
return(new HttpStatusCodeResult(400));
}
if (result == MemberWorker.RegisterStatus.Success)
{
MemberWorker.AddUserCookie(Response, email, 3600);
return(new JsonResult()
{
Data = "Registration completed successfully"
});
}
else
{
return(new JsonResult()
{
Data = false
});
}
}
catch (Exception)
{
return(new JsonResult()
{
Data = false
});
}
}
public ActionResult SignIn(String login, String pass)
{
object user = null;
var isLogged = MemberWorker.SignIn(login, pass);
switch (isLogged)
{
case MemberWorker.LoginStatus.Success:
{
user = Db.Context.Users.Where(x => x.Email == login).Select(x => new
{
x.Id,
x.Email,
x.FirstName,
x.LastName,
x.Logo
}).FirstOrDefault();
MemberWorker.AddUserCookie(Response, ((dynamic)user).Email, 3600);
Session["user"] = user;
return(new JsonResult()
{
Data = new { status = "OK", user = user }
});
}
case MemberWorker.LoginStatus.NotValid:
return(new JsonResult()
{
Data = new { status = "Invalid Email or Password", user = user }
});
case MemberWorker.LoginStatus.UserDoesNotExist:
return(new JsonResult()
{
Data = new { status = "User does not exist" }
});
default:
return(new HttpStatusCodeResult(400));
}
}
private static Int32?GetVoterState(SafeAdmission admission, HttpRequestBase request)
{
if (admission.UserIdentity != null)
{
using (var Db = new Repository())
{
var v = Db.Context.ProjectAccessVoters.Where(x => x.Id == admission.UserIdentity).FirstOrDefault();
v.IsUsed = true;
v.VotedOn = DateTime.Now;
Db.Save();
}
return(admission.UserIdentity);
}
HttpCookie cookie = request.Cookies[MemberWorker.GetAnonymousCookieName()];
if (cookie != null)
{
var val = cookie["Data"];
var voter = new ProjectAccessVoter();
using (var Db = new Repository())
{
UserSet user = new UserSet()
{
CookieValue = val
};
voter = new ProjectAccessVoter()
{
ProjectId = Db.Context.Projects.Where(x => x.UrlCode == admission.projectUrl).Select(x => x.Id).FirstOrDefault(), UserSet = user, IsUsed = true, ModifiedOn = DateTime.Now
};
voter.VotedOn = DateTime.Now;
Db.Context.ProjectAccessVoters.Add(voter);
Db.Save();
}
return(voter.Id);
}
else
{
return(null);
}
}
public async Task <bool> CheckLoginTaken(ObjectId roomId, string login) => await Task.Run(() => MemberWorker.CheckMemberInRoomByLogin(roomId, login));
public async Task SetTags(ObjectId memberId, MembersDB_TagDTO[] newValue)
{
await _redisCache.Del($"Member:{memberId}");
await MemberWorker.SetProperty(memberId, "Tags", newValue);
}
public ActionResult LogOut()
{
MemberWorker.SignOut();
Session["user"] = null;
return(RedirectToAction("Index", "Home"));
}
public async Task <bool> CheckEmailTaken(ObjectId roomId, string email) => await Task.Run(() => MemberWorker.CheckMemberInRoomByEmail(roomId, email));
public async Task <MembersDB_MemberDTO[]> GetMembersByRoomId(ObjectId roomId) => await Task.Run(() => MemberWorker.GetMembersByRoomId(roomId));
public async Task <MembersDB_MemberDTO[]> GetMembersByIds(ObjectId[] memberIds) => await Task.Run(() => MemberWorker.GetMembersByIds(memberIds));
public async Task <bool> SetProperties(ObjectId memberId, Dictionary <string, object> properties)
{
await _redisCache.Del($"Member:{memberId}");
return(await MemberWorker.SetProperties(memberId, properties));
}
public async Task <MembersDB_MemberDTO> GetMemberByAuthData(ObjectId roomId, string login, byte[] passwordHash) => await Task.Run(() => MemberWorker.GetMemberByAuthData(roomId, login, passwordHash));
public async Task <MembersDB_MemberDTO> GetMemberByFieldsHash(ObjectId roomId, byte[] fieldsHash) => await Task.Run(() => MemberWorker.GetMemberByFieldsHash(roomId, fieldsHash));
public async Task ReplaceMember(MembersDB_MemberDTO member)
{
await _redisCache.Del($"Member:{member.Id}");
await Task.Run(() => MemberWorker.ReplaceMember(member));
}
public async Task <ObjectId> InsertMember(MembersDB_MemberDTO newMember) => await Task.Run(() => MemberWorker.InsertMember(newMember));
public async Task <bool> SetProperty(ObjectId memberId, string propertyName, object newPropertyValue)
{
await _redisCache.Del($"Member:{memberId}");
return(await MemberWorker.SetProperty(memberId, propertyName, newPropertyValue));
}
public async Task <MembersDB_MemberDTO> GetMemberById(ObjectId memberId) =>
await _redisCache.Get <MembersDB_MemberDTO>($"Member:{memberId}", async() => await MemberWorker.GetMemberById(memberId));
