public void CreateUserContacts(IEnumerable <UserContactEntity> userContactsToUpdate)
{
var now = m_dateTimeProvider.UtcNow;
foreach (var userContactEntity in userContactsToUpdate)
{
userContactEntity.ActiveFrom = now;
m_userContactRepository.Create(userContactEntity);
}
}
public async Task <IdResult> ChangeInvitationState(Contact invitorUserProfile)
{
if (invitorUserProfile == null)
{
return(new IdResult()
{
IsOk = false,
ErrorMessage = "No user info"
});
}
var dbUser = DbUser;
using (UserContactRepository _userContactRepository = new UserContactRepository(Context, dbUser, null))
using (UserProfileRepository _userProfileRepository = new UserProfileRepository(Context, dbUser, null))
{
var invitorUserProfileFromDb = _userProfileRepository.GetById(invitorUserProfile.Id);
if (invitorUserProfile.Id != Guid.Empty && invitorUserProfileFromDb != null)
{
var userContactDB = _userContactRepository.GetByContactUserId(invitorUserProfileFromDb.Id, dbUser);
if (userContactDB != null)
{
userContactDB.State = invitorUserProfile.State;
userContactDB.StateDate = DateTime.Now;
var senderUser = _userProfileRepository.GetById(userContactDB.MainUserId);
if (invitorUserProfile.State == (byte)InvitationStates.Accepted)
{
_userContactRepository.Create(new UserContact()
{
ContactName = senderUser.FullName,
ContactUserId = senderUser.Id,
MainUserId = dbUser,
State = (int)InvitationStates.Accepted,
StateDate = DateTime.Now
});
Utilities.AddNotification(dbUser, userContactDB.MainUserId, dbUser, (int)NotificationTypes.InvitationToContactsConfirmed,
string.Format("You invitaion is accepted"));
}
Context.SaveChanges();
return(new IdResult()
{
IsOk = true,
Id = userContactDB.Id,
});
}
}
}
return(new IdResult()
{
IsOk = false,
ErrorMessage = "Error"
});
//var user = JsonConvert.DeserializeObject<UserRegister>(userData);
}
public async Task <BoolResult> InsertSystemInvitation(Invitation invitation)
{
if (invitation == null)
{
return(new BoolResult()
{
IsOk = false,
ErrorMessage = "No invitation info"
});
}
var dbUser = DbUser;
using (Common.Model.InvitationRepository _invitationRepository = new Common.Model.InvitationRepository(Context, dbUser, null))
using (UserContactRepository _userContactRepository = new UserContactRepository(Context, dbUser, null))
using (UserProfileRepository _userProfileRepository = new UserProfileRepository(Context, dbUser, null))
{
//checkIfPersonIsInUsers
var user = await UserManager.FindByEmailAsync(invitation.Email);
if (user == null)
{
//create Invitation
var invitationByEmail = _invitationRepository.GetInvitationDoesNotExistsByEmail(invitation.Email);
if (invitationByEmail.IsOk)
{
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
//create new Invitation
var activationCode = string.Empty;
_invitationRepository.Create(new Guid("c51c4a63-8278-4013-9639-8f9ac6775b72"), null,
invitation.Email, out activationCode);
Dictionary <string, string> values = new Dictionary <string, string>();
values.Add("[ActivationCode]", activationCode);
MessageHelper.SendMessage(MessageTemplateTypes.RegistrationActivationCode, values, null, invitation.Email, null, bccEmail: "*****@*****.**");
Context.SaveChanges();
transactionScope.Complete();
return(new BoolResult()
{
IsOk = true
});
}
catch (Exception e)
{
LogHelper.WriteError(e);
return(new BoolResult()
{
IsOk = false,
ErrorMessage = e.ToString()
});
}
}
}
//check if Invitation exists
return(new BoolResult()
{
IsOk = false,
ErrorMessage = invitationByEmail.ErrorMessage
});
}
//create contactInvitation
var invitationToContactsByUserId = _userContactRepository.GetInvitationInContactsDoesNotExistsByUserId(dbUser, user.UserProfile.Id);
if (invitationToContactsByUserId.IsOk)
{
_userContactRepository.Create(new UserContact()
{
ContactName = user.UserProfile.FullName,
ContactUserId = user.UserProfile.Id,
MainUserId = DbUser,
State = (int)InvitationStates.Pending,
StateDate = DateTime.Now
});
try
{
Context.SaveChanges();
var senderUser = _userProfileRepository.GetById(dbUser);
Utilities.AddNotification(dbUser, user.UserProfile.Id, dbUser, (int)NotificationTypes.InvitationToContactsRecieved,
string.Format("You are added to {0}'s contacts. Please Accept or Reject invitation", senderUser.FullName));
return(new BoolResult()
{
IsOk = true,
});
}
catch (Exception e)
{
LogHelper.WriteError(e);
}
}
return(new BoolResult()
{
IsOk = false,
ErrorMessage = invitationToContactsByUserId.ErrorMessage
});
}
//var invitation = _invitationRepository.GetById(user.InvitationId); ;
//if (invitation != null)
//{
// using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
// {
// try
// {
// var userRegistration = new ApplicationUser
// {
// UserName = user.Email,
// Email = user.Email,
// UserProfile = new Authentication.UserProfile() { Id = Guid.NewGuid(), FirstName = user.FirstName, LastName = user.LastName }
// };
// var result = await UserManager.CreateAsync(userRegistration, user.Password);
// if (result.Succeeded)
// {
// var addToRole = await this.UserManager.AddToRoleAsync(userRegistration.Id, MindCorners.Common.Code.Constants.GeneralUserRoleId);
// if (addToRole.Succeeded)
// {
// invitation.State = (int)InvitationStates.Valid;
// invitation.StateDate = DateTime.Now;
// _invitationRepository.Update(invitation);
// Context.SaveChanges();
// //_invitationRepository.SaveChanges();
// transactionScope.Complete();
// return new IdResult()
// {
// IsOk = true,
// Id = userRegistration.UserProfile.Id
// };
// }
// return new IdResult()
// {
// IsOk = false,
// ErrorMessage = string.Join(",", addToRole.Errors)
// };
// // return RedirectToAction("Index", "Home");
// }
// return new IdResult()
// {
// IsOk = false,
// ErrorMessage = string.Join(",", result.Errors)
// };
// }
// catch (Exception ex)
// {
// LogHelper.WriteError(ex);
// return new IdResult()
// {
// IsOk = false,
// ErrorMessage = ex.ToString()
// };
// }
// }
//}
}
public async Task <ObjectResult <User> > RegisterUser(UserRegister user)
{
if (user.InvitationId == Guid.Empty)
{
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = "No valid invitation exists"
});
}
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
var userRegistration = new ApplicationUser
{
UserName = user.Email,
Email = user.Email,
UserProfile =
new Authentication.UserProfile()
{
Id = Guid.NewGuid(),
FirstName = user.FirstName,
LastName = user.LastName
}
};
var result = await UserManager.CreateAsync(userRegistration, user.Password);
if (result.Succeeded)
{
var dbUser = userRegistration.UserProfile.Id;
using (InvitationRepository _invitationRepository = new InvitationRepository(Context, dbUser, null))
using (UserContactRepository userContactRepository = new UserContactRepository(Context, dbUser, null))
using (UserProfileRepository userProfileRepository = new UserProfileRepository(Context, dbUser, null))
{
var invitation = _invitationRepository.GetById(user.InvitationId);
if (invitation != null)
{
var addToRole =
await
this.UserManager.AddToRoleAsync(userRegistration.Id,
MindCorners.Common.Code.Constants.GeneralUserRoleId);
if (addToRole.Succeeded)
{
invitation.State = (int)InvitationStates.Accepted;
invitation.StateDate = DateTime.Now;
_invitationRepository.Update(invitation);
//add userToUserContacts
userContactRepository.Create(new UserContact()
{
ContactName = userRegistration.UserProfile.FullName,
ContactUserId = userRegistration.UserProfile.Id,
MainUserId = invitation.CreatorId,
State = (int)InvitationStates.Accepted,
StateDate = DateTime.Now
});
var invitationCreator = userProfileRepository.GetById(invitation.CreatorId);
userContactRepository.Create(new UserContact()
{
ContactName = invitationCreator.FullName,
ContactUserId = invitation.CreatorId,
MainUserId = userRegistration.UserProfile.Id,
State = (int)InvitationStates.Accepted,
StateDate = DateTime.Now
});
//add create Circle of two users
//var circle = new Common.Model.Circle() { IsGroup = false };
//CircleRepository circleRepository = new CircleRepository(Context, dbUser, null);
//circleRepository.Create(circle);
//Context.SaveChanges();
//circleRepository.AddMainPersonToCircleUser(circle.Id, dbUser);
//circleRepository.SynchCircleUsers(circle.Id, new List<Guid>() { userRegistration.UserProfile.Id });
Context.SaveChanges();
//_invitationRepository.SaveChanges();
transactionScope.Complete();
return(new ObjectResult <User>()
{
IsOk = true,
ReturnedObject = new User()
{
FirstName = userRegistration.UserProfile.FirstName,
LastName = userRegistration.UserProfile.LastName,
Email = userRegistration.Email,
FullName = userRegistration.UserProfile.FullName,
Id = userRegistration.UserProfile.Id,
//ProfileImage = applicationUser.UserProfile.ProfileImage,
ProfileImageString = Request.GetFileUrl((int)FileType.Profile, userRegistration.UserProfile.ProfileImageString)
}
});
}
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = string.Join(",", addToRole.Errors)
});
// return RedirectToAction("Index", "Home");
}
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = string.Join(",", result.Errors)
});
}
}
}
catch (Exception ex)
{
LogHelper.WriteError(ex);
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = ex.ToString()
});
}
//var user = JsonConvert.DeserializeObject<UserRegister>(userData);
}
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = "Error"
});
}
public async Task <ObjectResult <User> > RegisterExternal(RegisterExternalBindingModel model)
{
bool registrationOk = false;
if (!model.InvitationId.HasValue || model.InvitationId == Guid.Empty)
{
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = "No valid invitation exists"
});
}
// if (model.InvitationId.HasValue)
{
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
var userData = await GetFacebookProfileAsync(model.ExternalAccessToken);
var fileFullName = string.Empty;
if (userData.picture != null)
{
var picture = GetProfilePicture(userData.picture.data.url);
if (picture != null)
{
fileFullName = Utilities.UploadBlob("profile-images", string.Format("{0}{1}", Guid.NewGuid(), ".jpg"), picture);
}
}
var user = new ApplicationUser
{
UserName = model.UserName,
Email = model.UserName,
UserProfile = new Authentication.UserProfile()
{
Id = Guid.NewGuid(),
FirstName = userData.first_name,
LastName = userData.last_name,
MiddleName = userData.middle_name,
//ProfileImage = picture,
ProfileImageString = fileFullName
}
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
var info = new ExternalLoginInfo()
{
DefaultUserName = model.UserName,
Login = new UserLoginInfo(model.Provider, userData.id)
};
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
using (InvitationRepository _invitationRepository = new InvitationRepository(Context, user.UserProfile.Id, null))
using (UserContactRepository userContactRepository = new UserContactRepository(Context, user.UserProfile.Id, null))
using (UserProfileRepository userProfileRepository = new UserProfileRepository(Context, user.UserProfile.Id, null))
{
var invitation = _invitationRepository.GetById(model.InvitationId.Value);
if (invitation != null)
{
var role = DbContext.Roles.First(p => p.Id == invitation.RoleId.ToString());
var addToRole = await this.UserManager.AddToRoleAsync(user.Id, role != null?role.Name : MindCorners.Common.Code.Constants.GeneralUserRoleId);
if (addToRole.Succeeded)
{
invitation.State = (int)InvitationStates.Accepted;
invitation.StateDate = DateTime.Now;
_invitationRepository.Update(invitation);
//add userToUserContacts
userContactRepository.Create(new UserContact()
{
ContactName = user.UserProfile.FullName,
ContactUserId = user.UserProfile.Id,
MainUserId = invitation.CreatorId,
State = (int)InvitationStates.Accepted,
StateDate = DateTime.Now
});
var invitationCreator = userProfileRepository.GetById(invitation.CreatorId);
userContactRepository.Create(new UserContact()
{
ContactName = invitationCreator.FullName,
ContactUserId = invitation.CreatorId,
MainUserId = user.UserProfile.Id,
State = (int)InvitationStates.Accepted,
StateDate = DateTime.Now
});
//add create Circle of two users
//var circle = new Common.Model.Circle() { IsGroup = false };
//CircleRepository circleRepository = new CircleRepository(Context, dbUser, null);
//circleRepository.Create(circle);
//Context.SaveChanges();
//circleRepository.AddMainPersonToCircleUser(circle.Id, dbUser);
//circleRepository.SynchCircleUsers(circle.Id, new List<Guid>() { userRegistration.UserProfile.Id });
Context.SaveChanges();
//_invitationRepository.SaveChanges();
transactionScope.Complete();
return(new ObjectResult <User>()
{
IsOk = true,
ReturnedObject = new User()
{
FirstName = user.UserProfile.FirstName,
LastName = user.UserProfile.LastName,
Email = user.Email,
FullName = user.UserProfile.FullName,
Id = user.UserProfile.Id,
//ProfileImage = applicationUser.UserProfile.ProfileImage,
ProfileImageString = Request.GetFileUrl((int)FileType.Profile, user.UserProfile.ProfileImageString)
}
});
}
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = string.Join(",", addToRole.Errors)
});
// return RedirectToAction("Index", "Home");
}
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = "No valid Invitation"
});
}
}
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = string.Join(",", result.Errors)
});
}
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = string.Join(",", result.Errors)
});
//AddErrors(result);
}
catch (Exception ex)
{
LogHelper.WriteError(ex);
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = ex.ToString()
});
}
}
}
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
//var verifiedAccessToken = await VerifyExternalAccessToken(model.Provider, model.ExternalAccessToken);
//if (verifiedAccessToken == null)
//{
// return BadRequest("Invalid Provider or External Access Token");
//}
//user = new IdentityUser() { UserName = model.UserName };
//ApplicationUser user = await UserManager.CreateAsync(new UserLoginInfo(model.Provider, model.ExternalAccessToken));
// bool hasRegistered = user != null;
// if (hasRegistered)
// {
// return BadRequest("External user is already registered");
// }
//// user = new IdentityUser() { UserName = model.UserName };
// IdentityResult result = await UserManager.CreateAsync(user);
// if (!result.Succeeded)
// {
// return GetErrorResult(result);
// }
// var info = new ExternalLoginInfo()
// {
// DefaultUserName = model.UserName,
// Login = new UserLoginInfo(model.Provider, verifiedAccessToken.user_id)
// };
// result = await _repo.AddLoginAsync(user.Id, info.Login);
// if (!result.Succeeded)
// {
// return GetErrorResult(result);
// }
// //generate access token response
// var accessTokenResponse = GenerateLocalAccessTokenResponse(model.UserName);
// return Ok(accessTokenResponse);
return(new ObjectResult <User>()
{
IsOk = false,
ErrorMessage = "Error"
});
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
//var ext =
// await AuthenticationManager.GetExternalIdentityAsync(DefaultAuthenticationTypes.ExternalCookie);
//var email = ext.Claims.First(x => x.Type.EndsWith("emailaddress")).Value;
//var name = ext.Claims.First(x => x.Type.EndsWith("name")).Value;
//var nameIdentifier = ext.Claims.First(x => x.Type.EndsWith("nameidentifier")).Value;
var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
//var firstNameClaim = loginInfo.ExternalIdentity.Claims.First(c => c.Type == "urn:facebook:first_name");
string firstName = string.Empty;
string lastName = string.Empty;
string middleName = string.Empty;
string email = string.Empty;
byte[] picture = null;
if (loginInfo.Login.LoginProvider == "Facebook")
{
var identity = AuthenticationManager.GetExternalIdentity(DefaultAuthenticationTypes.ExternalCookie);
var access_token = identity.FindFirstValue("FacebookAccessToken");
var fb = new FacebookClient(access_token);
dynamic myInfo = fb.Get("/me?fields=first_name,middle_name,last_name,id,email,picture.width(600)");
// specify the email field
loginInfo.Email = myInfo.email;
firstName = myInfo.first_name;
middleName = myInfo.middle_name;
lastName = myInfo.last_name;
picture = GetProfilePicture(GetFacebookImageUrl(myInfo));
}
bool registrationOk = false;
if (InvitationId.HasValue)
{
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
var fileFullName = string.Empty;
if (picture != null)
{
fileFullName = Utilities.UploadBlob("profile-images", string.Format("{0}{1}", Guid.NewGuid(), ".jpg"), picture);
}
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
UserProfile = new UserProfile()
{
Id = Guid.NewGuid(),
FirstName = firstName,
LastName = lastName,
MiddleName = middleName,
//ProfileImage = picture,
ProfileImageString = fileFullName
}
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
using (InvitationRepository _invitationRepository = new InvitationRepository(Context, user.UserProfile.Id, null))
using (UserContactRepository userContactRepository = new UserContactRepository(Context, user.UserProfile.Id, null))
using (UserProfileRepository userProfileRepository = new UserProfileRepository(Context, user.UserProfile.Id, null))
{
var invitation = _invitationRepository.GetById(InvitationId.Value);
if (invitation != null)
{
var role = DbContext.Roles.First(p => p.Id == invitation.RoleId.ToString());
var addToRole = await this.UserManager.AddToRoleAsync(user.Id, role != null?role.Name : MindCorners.Common.Code.Constants.GeneralUserRoleId);
if (addToRole.Succeeded)
{
invitation.State = (int)InvitationStates.Accepted;
invitation.StateDate = DateTime.Now;
_invitationRepository.Update(invitation);
//add userToUserContacts
userContactRepository.Create(new UserContact()
{
ContactName = user.UserProfile.FullName,
ContactUserId = user.UserProfile.Id,
MainUserId = invitation.CreatorId,
State = (int)InvitationStates.Accepted,
StateDate = DateTime.Now
});
var invitationCreator = userProfileRepository.GetById(invitation.CreatorId);
userContactRepository.Create(new UserContact()
{
ContactName = invitationCreator.FullName,
ContactUserId = invitation.CreatorId,
MainUserId = user.UserProfile.Id,
State = (int)InvitationStates.Accepted,
StateDate = DateTime.Now
});
//add create Circle of two users
//var circle = new Common.Model.Circle() { IsGroup = false };
//CircleRepository circleRepository = new CircleRepository(Context, dbUser, null);
//circleRepository.Create(circle);
//Context.SaveChanges();
//circleRepository.AddMainPersonToCircleUser(circle.Id, dbUser);
//circleRepository.SynchCircleUsers(circle.Id, new List<Guid>() { userRegistration.UserProfile.Id });
Context.SaveChanges();
//_invitationRepository.SaveChanges();
transactionScope.Complete();
}
registrationOk = true;
}
}
}
if (registrationOk)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
}
AddErrors(result);
}
catch (Exception ex)
{
LogHelper.WriteError(ex);
}
}
//var user = new ApplicationUser
//{
// UserName = model.Email,
// Email = model.Email,
// UserProfile = new UserProfile()
// {
// Id = Guid.NewGuid(),
// FirstName = firstName,
// LastName = lastName,
// MiddleName = middleName,
// ProfileImage = picture,
// }
//};
//var result = await UserManager.CreateAsync(user);
//if (result.Succeeded)
//{
// result = await UserManager.AddLoginAsync(user.Id, info.Login);
// if (result.Succeeded)
// {
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// return RedirectToLocal(returnUrl);
// }
//}
}
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}