public IActionResult Privacy(string id)
{
AccountPrivacy privacy = dbContext.accountPrivacy.SingleOrDefault(ap => ap.userId == id);
string x = HttpContext.Session.GetString("userId");
return(Ok(mapper.Map <AccountPrivacy, AccountPrivacyDto>(privacy)));
}
public void UpdatePrivacy(int accountId,
bool profileImg,
bool statusText,
bool lastSeen,
bool phone,
bool birthday,
bool address,
bool socials,
bool acceptAllMessages)
{
AccountPrivacy accountPrivacy = _context.AccountPrivacies.FirstOrDefault(p => p.AccountId == accountId);
if (accountPrivacy != null)
{
accountPrivacy.ProfileImg = profileImg;
accountPrivacy.StatusText = statusText;
accountPrivacy.Phone = phone;
accountPrivacy.LastSeen = lastSeen;
accountPrivacy.Birthday = birthday;
accountPrivacy.Address = address;
accountPrivacy.SocialLink = socials;
accountPrivacy.AcceptAllMessages = acceptAllMessages;
_context.SaveChanges();
}
}
//create account's privacy Database
public void CreatePrivacy(AccountPrivacy accountPrivacy)
{
if (accountPrivacy != null)
{
_context.AccountPrivacies.Add(accountPrivacy);
_context.SaveChanges();
}
}
public async Task <IActionResult> Register([FromForm] RegisterViewModel model)
{
string regNo = model.season + "-" + model.department + "-" + model.roll;
bool regAlreadyExist = dbContext.Users.Any(u => u.regNo == regNo);
if (regAlreadyExist)
{
ModelState.AddModelError("", "Registration No Already Exist");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = model.Email,
Email = model.Email,
DOB = model.DOB,
firstName = model.firstName,
lastName = model.lastName,
profilePicture = model.profilePictureName,
facebookLink = model.facebookLink,
instagramLink = model.instagramLink,
twitterLink = model.twitterLink,
regNo = regNo
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var privacy = new AccountPrivacy()
{
emailIsPublic = false,
instagramIsPublic = false,
twitterIsPublic = false,
facebookIsPublic = false,
phoneIsPublic = false,
userId = user.Id
};
dbContext.accountPrivacy.Add(privacy);
dbContext.SaveChanges();
return(Ok());
}
foreach (var err in result.Errors)
{
ModelState.AddModelError("", err.Description);
}
return(BadRequest(ModelState));
}
public IActionResult Update(string id, [FromBody] SettingViewMolde model)
{
model.user.UserName = model.user.Email;
ApplicationUser user = dbContext.Users.SingleOrDefault(m => m.Id == id);
AccountPrivacy privacy = dbContext.accountPrivacy.SingleOrDefault(m => m.userId == id);
mapper.Map <UserDto, ApplicationUser>(model.user, user);
mapper.Map <AccountPrivacyDto, AccountPrivacy>(model.privacy, privacy);
dbContext.SaveChanges();
return(Ok(model));
}
public AccountSocialLink GetPublicSocialLinks(int id)
{
Account account = _context.Accounts.Find(id);
AccountPrivacy accountPrivacy = _context.AccountPrivacies.FirstOrDefault(p => p.AccountId == account.Id);
AccountSocialLink accountSocial = _context.AccountSocialLinks.FirstOrDefault(s => s.AccountId == account.Id);
if (accountPrivacy.SocialLink)
{
return(accountSocial);
}
else
{
accountSocial.Facebook = null;
accountSocial.Twitter = null;
accountSocial.Instagram = null;
accountSocial.Linkedin = null;
return(accountSocial);
}
}
public IActionResult SignUp(RegisterViewModel model)
{
bool checkUser = _authRepository.CheckEmail(model.Email);
bool number = _authRepository.CheckPhone(model.Phone);
if (checkUser)
{
ModelState.AddModelError("Email", "Bu E-mail artiq movcuddur");
}
if (number)
{
ModelState.AddModelError("Phone", "Bu Nömrə artıq mövcuddur");
}
if (ModelState.IsValid)
{
var user = _mapper.Map<RegisterViewModel, Account>(model);
user.Fullname = model.Name + " " + model.Surname;
user.Token = Guid.NewGuid().ToString();
user.Status = true;
user.IsEmailVerified = false;
//email verification code
user.EmailActivationCode = Guid.NewGuid().ToString();
_authRepository.Register(user);
AccountSocialLink accountSocialLink = new AccountSocialLink
{
AccountId = user.Id,
Status = true,
AddedBy = "System",
AddedDate = DateTime.Now
};
_authRepository.AddedSocial(accountSocialLink);
//creating account's privacy Database
AccountPrivacy accountPrivacy = new AccountPrivacy
{
AccountId = user.Id,
Status = true,
AddedDate = DateTime.Now,
AddedBy = "System",
Phone = true,
Email = true,
LastLogin = true,
LastSeen = true,
Address = true,
Birthday = true,
ProfileImg = true,
SocialLink = true,
StatusText = true,
Website = true
};
_authRepository.CreatePrivacy(accountPrivacy);
AccountSecurity accountSecurity = new AccountSecurity
{
AccountId=user.Id,
TwoFactoryAuth = false,
LoginAlerts = false
};
_authRepository.CreateSecurity(accountSecurity);
//send verification link email
string userFullname = user.Name + " " + user.Surname;
string link = HttpContext.Request.Scheme + "://" + Request.Host + "/account/verifyemail/" + user.EmailActivationCode;
_emailService.VerificationEmail(user.Email, link, user.EmailActivationCode, userFullname);
Response.Cookies.Append("token", user.Token, new Microsoft.AspNetCore.Http.CookieOptions
{
HttpOnly = true,
Expires = DateTime.Now.AddYears(1)
});
return RedirectToAction("chat1", "pages");
}
return View(model);
}
public SearchAccount GetDatasPublic(int currentAccountId, int accountId)
{
Account account = _context.Accounts.Find(accountId);
AccountPrivacy accountPrivacy = _context.AccountPrivacies.FirstOrDefault(p => p.AccountId == account.Id);
if (accountPrivacy != null)
{
SearchAccount searchItem = new SearchAccount();
//id
searchItem.Id = account.Id;
//fullname
searchItem.Label = account.Fullname;
//friendship
//FriendshipStatus friendshipStatus = _friendsRepository.GetFriendshipStatus(currentAccountId, accountId);
Friend friendship = _friendsRepository.GetFriendship(currentAccountId, accountId);
if (friendship != null)
{
if (friendship.StatusCode != FriendshipStatus.Error)
{
searchItem.Friendship = friendship.StatusCode;
}
if (friendship.FromUserId == currentAccountId)
{
searchItem.IsFriendRequestSender = true;
}
}
else
{
//static for if error ocoured
searchItem.Friendship = FriendshipStatus.NotFriend;
}
//email
searchItem.Email = account.Email; // static public
//address
if (accountPrivacy.Address == false)
{
searchItem.Address = null;
}
else
{
searchItem.Address = account.Address;
}
//website
if (accountPrivacy.Website == false)
{
searchItem.Website = null;
}
else
{
searchItem.Website = account.Website;
}
//birthday
if (accountPrivacy.Birthday == false)
{
searchItem.Birthday = null;
}
else
{
searchItem.Birthday = account.Birthday;
}
//phone
if (accountPrivacy.Phone == false)
{
searchItem.Phone = null;
}
else
{
searchItem.Phone = account.Phone;
}
//profile img
if (accountPrivacy.ProfileImg == false)
{
searchItem.Img = null;
}
else
{
searchItem.Img = account.ProfileImg;
}
//status text
if (accountPrivacy.StatusText == false)
{
searchItem.StatusText = null;
}
else
{
searchItem.StatusText = account.StatusText;
}
//social links
if (accountPrivacy.SocialLink == false)
{
searchItem.Facebook = null;
searchItem.Twitter = null;
searchItem.Instagram = null;
searchItem.Linkedin = null;
}
else
{
AccountSocialLink accountSocials = _context.AccountSocialLinks.FirstOrDefault(a => a.AccountId == accountId);
searchItem.Facebook = accountSocials.Facebook;
searchItem.Twitter = accountSocials.Twitter;
searchItem.Instagram = accountSocials.Instagram;
searchItem.Linkedin = accountSocials.Linkedin;
}
//if (accountPrivacy.AcceptAllMessages == false) //PROBLEM!!!
//{
//
//}
return(searchItem);
}
return(null);
}
