public async Task UpdatePassword(LoggedUserDTO user)
{
var db = _connectionMultiplexer.GetDatabase();
var users = db.StreamRead("logged_users", "0-0");
LoggedUserDTO entryUser = new LoggedUserDTO();
RedisValue idEntryUser = new RedisValue();
bool exists = false;
foreach (StreamEntry entry in users)
{
if (entry.Values[0].Name == user.Username)
{
exists = true;
idEntryUser = entry.Id;
entryUser = JsonSerializer.Deserialize <LoggedUserDTO>(entry.Values[0].Value.ToString());
break;
}
}
if (exists)
{
db.StreamDelete("logged_users", new[] { idEntryUser });
user.Role = entryUser.Role;
user.LoggedIn = entryUser.LoggedIn;
user.Username = entryUser.Username;
db.StreamAdd("logged_users", user.Username, JsonSerializer.Serialize <LoggedUserDTO>(user));
}
}
public async Task<RentererDTO> AddRenterer(RentererDTO renterer)
{
var flag = this.IfRentererExists(renterer.Username).Result;
if (flag == false)
{
var result = _client.Cypher.Create("(renterer:Renterer {renterer})").WithParams(new { renterer }).Set("renterer.Id = id(renterer)").Return(renterer => new
{
Renterer = renterer.As<Renterer>()
}).ResultsAsync;
LoggedUserDTO user = new LoggedUserDTO(renterer.Name, renterer.Password, true, "renterer");
await _redisRepository.AddNewLoggedUser(user);
return renterer;
}
return null;
}
private void Page_Load(object sender, System.EventArgs e)
{
LoggedUser oLoggedUser = (LoggedUser)HttpContext.Current.User;
//XmlSerializer xmlSerializer = new XmlSerializer(typeof(LoggedUser));
//StringWriter stringWriter = new StringWriter();
//XmlWriter xmlWriter = XmlWriter.Create(stringWriter);
//xmlSerializer.Serialize(xmlWriter, oLoggedUser);
//var xml = stringWriter.ToString(); // Your xml
LoggedUserDTO loggedUserDTO = FillLogeedUserDTO(oLoggedUser);
Session["LoggedUser"] = loggedUserDTO;
long UserID = oLoggedUser.Profile.UserID;
string strSessionId = Session.SessionID;
Session["UserInfo"] = oLoggedUser.Profile.FirstName;
//********Remove MenuITems from Cache*************
Session["ApplicationMode"] = null;
HttpContext.Current.Cache.Remove("MenuApplicationDropdown_" + UserID + "_" + strSessionId);
HttpContext.Current.Cache.Remove("MenuBar_" + UserID + "_" + strSessionId);
HttpContext.Current.Cache.Remove("ApplicationMode_" + UserID + "_" + strSessionId);
//**************************************************
string strRedirectToURL = string.Empty;
if (Session["ReturnUrl"] != null && Session["ReturnUrl"].ToString() != String.Empty)
{
strRedirectToURL = Session["ReturnUrl"].ToString();
//string strt = Session["Type"].ToString();
if (Session["Type"] != null && Session["Type"].ToString().ToUpper() == "NEW")
{
Response.Redirect(strRedirectToURL);
Session["Type"] = null;
return;
}
else
{
strRedirectToURL = strRedirectToURL.Replace(strRedirectToURL.Substring(strRedirectToURL.IndexOf('/'), strRedirectToURL.IndexOf("/", 1)), String.Empty);
}
}
if (strRedirectToURL != string.Empty && strRedirectToURL.ToLower() != "/default.aspx" && strRedirectToURL.ToLower().IndexOf("security") < 0 && strRedirectToURL.Trim() != "/")
{
Response.Redirect(ApplicationBaseURL + strRedirectToURL);
}
else
{
Response.Redirect(ApplicationBaseURL + "Dashboard.aspx");
}
}
public async Task <LoggedUserDTO> CheckIfUserIsLoggedIn(LoggedUserDTO user)
{
var db = _connectionMultiplexer.GetDatabase();
var users = db.StreamRead("logged_users", "0-0");
foreach (StreamEntry entry in users)
{
if (entry.Values[0].Name == user.Username)
{
LoggedUserDTO entryUser = JsonSerializer.Deserialize <LoggedUserDTO>(entry.Values[0].Value.ToString());
if (entryUser.Password == user.Password && entryUser.LoggedIn)
{
return(entryUser);
}
}
}
return(null);
}
public IActionResult Authenticate([FromBody] LoginDTO dto)
{
var user = this.userService.Authenticate(dto.Username, dto.Password);
if (user == null)
{
return(Unauthorized());
}
var responseDTO = new LoggedUserDTO()
{
Username = user.Username,
Token = user.Token,
Id = user.Id
};
return(Ok(responseDTO));
}
public async Task <RenteeDTO> AddRentee(RenteeDTO rentee)
{
var flag = this.IfRenteeExists(rentee.Username).Result;
if (flag == false)
{
var result = _client.Cypher.Create("(rentee:Rentee {rentee})").WithParams(new { rentee }).Return(rentee => new
{
Rentee = rentee.As <Rentee>()
}).ResultsAsync;
Rentee renteee = result.Result.First().Rentee;
Console.WriteLine(renteee.Id.ToString());
LoggedUserDTO user = new LoggedUserDTO(rentee.Username, rentee.Password.ToString(), true, "rentee");
await _redisRepository.AddNewLoggedUser(user);
return(rentee);
}
return(null);
}
public async Task <LoggedUserDTO> LogInUser(LoggedUserDTO user)
{
var db = _connectionMultiplexer.GetDatabase();
var users = await db.StreamReadAsync("logged_users", "0-0");
LoggedUserDTO entryUser = new LoggedUserDTO();
RedisValue idEntryUser = new RedisValue();
bool exists = false;
foreach (StreamEntry entry in users)
{
if (entry.Values[0].Name == user.Username)
{
exists = true;
idEntryUser = entry.Id;
entryUser = JsonSerializer.Deserialize <LoggedUserDTO>(entry.Values[0].Value.ToString());
break;
}
}
if (!exists)
{
return(null);
}
else
{
db.StreamDelete("logged_users", new[] { idEntryUser });
entryUser.LoggedIn = true;
db.StreamAdd("logged_users", entryUser.Username, JsonSerializer.Serialize <LoggedUserDTO>(entryUser));
//var subscriber = _connectionMultiplexer.GetSubscriber();
//subscriber.Subscribe($"notifications:{entryUser.Id}").OnMessage(message =>
//{
// NotificationDTO deserializedMessage = JsonSerializer.Deserialize<NotificationDTO>(message.Message);
// string groupName = $"notification:{deserializedMessage.ReceiverId}";
// //_ = _hub.Clients.Group(groupName).SendAsync("ReceiveFriendRequests", deserializedMessage);
// //string groupName = $"requests:{deserializedMessage.ReceiverId}:friendship";
//});
return(entryUser);
}
}
public async Task AddNewLoggedUser(LoggedUserDTO user)
{
var db = _connectionMultiplexer.GetDatabase();
var users = await db.StreamReadAsync("logged_users", "0-0");
bool exists = false;
foreach (StreamEntry entry in users)
{
if (entry.Values[0].Name == user.Username)
{
exists = true;
}
}
if (!exists)
{
user.LoggedIn = false;
db.StreamAdd("logged_users", user.Username, JsonSerializer.Serialize <LoggedUserDTO>(user));
}
}
public ActionResult <LoggedUserDTO> Authenticate([FromBody] LoginDTO dto)
{
var user = this.userService.Authenticate(dto.Username, dto.Password);
if (user == null)
{
return(Unauthorized());
}
var responseDto = new LoggedUserDTO()
{
Username = user.Username,
Email = user.Email,
Token = user.Token,
Id = user.Id,
Image = user.Image
};
return(responseDto);
}
private LoggedUserDTO FillLogeedUserDTO(LoggedUser oLoggedUser)
{
LoggedUserDTO loggedUserDTO = new LoggedUserDTO();
loggedUserDTO.identity = oLoggedUser.Identity;
loggedUserDTO.Email = oLoggedUser.Profile.Email;
loggedUserDTO.FirstName = oLoggedUser.Profile.FirstName;
loggedUserDTO.MiddleName = oLoggedUser.Profile.MiddleName;
loggedUserDTO.UserName = oLoggedUser.Profile.UserName;
loggedUserDTO.FullName = oLoggedUser.Profile.FullName;
loggedUserDTO.LastName = oLoggedUser.Profile.LastName;
loggedUserDTO.SessionId = oLoggedUser.Profile.SessionID;
loggedUserDTO.IPAddress = oLoggedUser.Profile.IPAddress;
loggedUserDTO.UserID = oLoggedUser.Profile.UserID;
loggedUserDTO.IsBatchNumberLogin = oLoggedUser.Profile.IsBatchNumberLogin;
loggedUserDTO.TimeZone = oLoggedUser.UserSettings.TimeZone;
loggedUserDTO.DateFormat = oLoggedUser.UserSettings.DateFormat;
loggedUserDTO.PreferredCSS = oLoggedUser.UserSettings.PreferredCSS;
loggedUserDTO.PreferredLanguage = oLoggedUser.UserSettings.PreferredLanguage;
return(loggedUserDTO);
}
public async Task RemoveLoggedUser(LoggedUserDTO user)
{
var db = _connectionMultiplexer.GetDatabase();
var users = await db.StreamReadAsync("logged_users", "0-0");
bool exists = false;
RedisValue val = new RedisValue();
foreach (StreamEntry entry in users)
{
if (entry.Values[0].Name == user.Username)
{
exists = true;
val = entry.Id;
break;
}
}
if (exists)
{
db.StreamDelete("logged_users", new[] { val });
}
}
public async Task UpdatePassword([FromBody] LoggedUserDTO user)
{
await _redisService.UpdatePassword(user);
}
public async Task <IActionResult> CheckIfUserIsLoggedIn([FromBody] LoggedUserDTO user)
{
var value = await _redisService.CheckIfUserIsLoggedIn(user);
return(Ok(value));
}
public async Task <IActionResult> LogOutUser([FromBody] LoggedUserDTO user)
{
await _redisService.LogOutUser(user);
return(Ok());
}
public async Task <LoggedUserDTO> CheckIfUserIsLoggedIn(LoggedUserDTO user)
{
return(await this._redisRepository.CheckIfUserIsLoggedIn(user));
}
public async Task <LoggedUserDTO> LogInUser(LoggedUserDTO user)
{
return(await this._redisRepository.LogInUser(user));
}
public async Task AddNewLoggedUser(LoggedUserDTO user)
{
await _redisRepository.AddNewLoggedUser(user);
}
public async Task RemoveLoggedUser(LoggedUserDTO user)
{
await _redisRepository.RemoveLoggedUser(user);
}
public async Task AddNewLoggedUser([FromBody] LoggedUserDTO user)
{
await _redisService.AddNewLoggedUser(user);
}
public async Task LogOutUser(LoggedUserDTO user)
{
await this._redisRepository.LogOutUser(user);
}
public async Task RemoveLoggedUser([FromBody] LoggedUserDTO user)
{
await _redisService.RemoveLoggedUser(user);
}
public async Task UpdatePassword(LoggedUserDTO user)
{
await _redisRepository.UpdatePassword(user);
}
public async Task <IActionResult> LogInUser([FromBody] LoggedUserDTO user)
{
LoggedUserDTO value = await _redisService.LogInUser(user);
return(value == null ? (IActionResult)NotFound() : Ok(value));
}
