public async Task <Contact> GetByIdWithState(Guid userId)
{
var dbUser = DbUser;
using (UserProfileRepository _userProfileRepository = new UserProfileRepository(Context, dbUser, null))
using (UserContactRepository _userContactRepository = new UserContactRepository(Context, dbUser, null))
{
var user = _userProfileRepository.GetById(userId);
if (user != null)
{
var userContact = _userContactRepository.GetByContactUserId(user.Id, dbUser);
return(new Contact()
{
Id = user.Id,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
State = userContact?.State,
ProfileImageString = Request.GetFileUrl((int)FileType.Profile, user.ProfileImageString)
});
}
return(new Contact());
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public UserContactRepository UserContacts()
{
if (_userContacts == null)
{
_userContacts = new UserContactRepository(context);
}
return(_userContacts);
}
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 void SetUp()
{
user1 = new User {
Email = "*****@*****.**"
};
user2 = new User {
Email = "*****@*****.**"
};
Context.Users.Add(user1);
Context.Users.Add(user2);
Context.SaveChanges();
userContactRepository = new UserContactRepository(Context);
}
public async Task <List <Contact> > GetOnlySelectedForCircle(Guid circleId)
{
using (UserContactRepository _userContactRepository = new UserContactRepository(Context, DbUser, null))
{
var selectedUsers = _userContactRepository.GetAllCircleUsers(circleId);
if (selectedUsers != null)
{
return(selectedUsers.Select(p => new Contact()
{
Id = p.Id,
Email = p.Email,
FirstName = p.FirstName,
LastName = p.LastName,
ProfileImageString = p.ProfileImageString,
IsSelected = true
}).ToList());
}
return(new List <Contact>());
}
}
public async Task <List <Contact> > GetAllWithSelectedForCircle(Guid circleId)
{
var dbUser = DbUser;
using (UserContactRepository _userContactRepository = new UserContactRepository(Context, dbUser, null))
{
var selectedUsers = _userContactRepository.GetAllByCircleIdAndUserId(dbUser, circleId);
if (selectedUsers != null)
{
return(selectedUsers.Select(p => new Contact()
{
Id = p.Id,
//Email = p.Email,
FirstName = p.FirstName,
LastName = p.LastName,
ProfileImageString = p.ProfileImageString,
IsSelected = p.IsSelectedInCircle
}).ToList());
}
return(new List <Contact>());
}
}
public UserContactVersioningProxyTest()
{
var databaseFactory = new MemoryDatabaseFactory();
var mappings = new AuthorizationMappingProvider().GetMappings();
m_sessionManager = new MockDbFactory(databaseFactory, mappings).CreateSessionManager(true);
var mockFactory = new MockRepository(MockBehavior.Loose)
{
CallBase = true
};
m_userContactRepository = mockFactory.Create <UserContactRepository>(m_sessionManager).Object;
var userContactComparerMock = mockFactory.Create <UserContactEqualityComparer>();
m_dateTimeProviderMock = mockFactory.Create <IDateTimeProvider>();
m_dateTimeProviderMock.Setup(x => x.UtcNow).Returns(DateTime.UtcNow);
m_contactVersioningProxy = new UserContactVersioningProxy(m_userContactRepository, userContactComparerMock.Object, m_dateTimeProviderMock.Object);
m_testUser = CreateTestUser(UsernameValue);
m_lowLevelOfAssurance = CreateTestLoa(MediumLoa);
m_userDataSource = CreateTestDataSource(DataSourceEnum.User);
}
public async Task <List <Contact> > GetAll(Guid userId)
{
var dbUser = DbUser;
using (UserContactRepository _userContactRepository = new UserContactRepository(Context, dbUser, null))
{
var contacts = _userContactRepository.GetAllByUserId(dbUser);
if (contacts != null)
{
return(contacts.Select(p => new Contact()
{
Id = p.Id,
Email = p.Email,
FirstName = p.FirstName,
LastName = p.LastName,
ProfileImageString = Request.GetFileUrl((int)FileType.Profile, p.ProfileImageString),
IsActivated = p.ContactState == (int)InvitationStates.Accepted
}).ToList());
}
return(new List <Contact>());
}
}
public async Task <FilePathResult> SubmitPostAndAttachment(Models.PostAndPostAttachment post)
{
var file = post.AttachmentFile;
var item = post.PostAttachment;
if (post.Post == null)
{
return(new FilePathResult()
{
IsOk = false,
ErrorMessage = "No post info"
});
}
if (item == null)
{
return(new FilePathResult()
{
IsOk = false,
ErrorMessage = "No post attachment info"
});
}
if (post.IsFile && (post.AttachmentFile == null || post.AttachmentFile.FileData == null))
{
return(new FilePathResult()
{
IsOk = false,
ErrorMessage = "No file info"
});
}
Common.Model.Post itemDb = null;
var dbUser = DbUser;
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
using (PostRepository _postRepository = new PostRepository(Context, dbUser, null))
using (UserContactRepository _userContactRepository = new UserContactRepository(Context, dbUser, null))
using (PostAttachmentRepostitory _postAttachmentRepostitory = new PostAttachmentRepostitory(Context, dbUser, null))
{
{
try
{
if (post.Post.Id == Guid.Empty)
{
//if (item.SelectedContact != null)
//{
// var contactCircle = _userContactRepository.GetCircleByUsersPair(dbUser,
// item.SelectedContact.Id);
// if (contactCircle != null)
// {
// item.SelectedCircle = new Circle() { Id = contactCircle.Id };
// }
//}
itemDb = new Common.Model.Post()
{
Title = post.Post.Title,
Type = post.Post.Type,
CircleId = post.Post.CircleId ?? post.Post.SelectedCircle?.Id,
UserId = post.Post.UserId ?? post.Post.SelectedContact?.Id,
ParentId = post.Post.ParentId
//LastUpdatedDate = DateTime.Now,
//LastUpdatedUserId = dbUser,
};
_postRepository.Create(itemDb);
}
else
{
itemDb = _postRepository.GetById(post.Post.Id);
itemDb.Title = post.Post.Title;
itemDb.Type = post.Post.Type;
_postRepository.Update(itemDb);
}
Context.SaveChanges();
/*Add Attachment*/
Common.Model.PostAttachment itemAttachmentDb = null;
try
{
itemAttachmentDb = new Common.Model.PostAttachment()
{
PostId = itemDb.Id,
Text = item.Text,
Type = item.Type.HasValue ? item.Type.Value : (int)ChatType.Text,
FilePath = item.FilePath,
FileDuration = item.FileDuration,
IsMainAttachment = item.IsMainAttachment
//LastUpdatedDate = DateTime.Now,
//LastUpdatedUserId = dbUser,
};
_postAttachmentRepostitory.Create(itemAttachmentDb);
Context.SaveChanges();
}
catch (Exception e)
{
LogHelper.WriteError(e);
return(new FilePathResult()
{
IsOk = false,
ErrorMessage = e.ToString()
});
}
if (itemDb != null)
{
if (itemDb.Type == (int)PostTypes.Prompt)
{
if (itemDb.UserId.HasValue)
{
Utilities.AddNotification(dbUser, itemDb.UserId.Value, itemDb.Id,
(int)NotificationTypes.NewPromptInCircle,
string.Format("You've got new Prompt"));
}
else if (itemDb.CircleId.HasValue)
{
var usersOfCircle = _userContactRepository.GetAllCircleUsers(itemDb.CircleId.Value);
if (usersOfCircle != null)
{
foreach (var userProfile in usersOfCircle)
{
Utilities.AddNotification(dbUser, userProfile.Id, itemDb.Id,
(int)NotificationTypes.NewPromptInCircle,
string.Format("You've got new Prompt"));
}
}
}
}
else if (itemDb.Type == (int)PostTypes.Reply && itemDb.ParentId.HasValue)
{
var parentPost = _postRepository.GetById(itemDb.ParentId.Value);
if (parentPost != null && parentPost.CreatorId != dbUser)
{
Utilities.AddNotification(dbUser, parentPost.CreatorId, parentPost.Id,
(int)NotificationTypes.Reply,
string.Format("You've got new Reply on you post:{0}", parentPost.Title));
}
}
else if (itemDb.Type == (int)PostTypes.TellMeMore && itemDb.ParentId.HasValue)
{
var parentReplyPost = _postRepository.GetById(itemDb.ParentId.Value);
if (parentReplyPost != null && parentReplyPost.ParentId.HasValue)
{
var parentPost = _postRepository.GetById(parentReplyPost.ParentId.Value);
if (parentPost != null)
{
Utilities.AddNotification(dbUser, parentReplyPost.CreatorId, parentPost.Id,
(int)NotificationTypes.TellMeMore,
string.Format("You've got TellMeMore on you reply in post:{0}",
parentPost.Title));
}
}
}
}
if (!post.IsFile)
{
transactionScope.Complete();
return(new FilePathResult()
{
PostId = itemDb.Id,
Id = itemAttachmentDb.Id,
IsOk = true
});
}
/*Add file here*/
var fileUnicName = Guid.NewGuid();
var fileExtention = Path.GetExtension(file.FileName);
var fileNewName = string.Format("{0}{1}", fileUnicName, fileExtention);
Common.Code.Utilities.UploadBlob(Common.Code.Utilities.GetAzureFolderByFileType(file.AttachmentType), fileNewName, file.FileData);
//ConfigurationManager.AppSettings["RootPathToFiles"];
//var request = ;
try
{
itemAttachmentDb.FilePath = fileNewName;
Context.SaveChanges();
string thumbnailUrl = null;
if (file.AttachmentType == (int)ChatType.Video)
{
var thumbNailFile = string.Format("Thumb_{0}.png", fileUnicName);
Common.Code.Utilities.UploadBlob(Common.Code.Utilities.GetAzureFolderByFileType(file.AttachmentType), thumbNailFile, file.ThumbnailFileData);
thumbnailUrl = Request.GetFileUrl((int)FileType.Video, thumbNailFile);
}
transactionScope.Complete();
return(new FilePathResult()
{
PostId = itemDb.Id,
Id = itemAttachmentDb.Id,
IsOk = true,
FileName = fileNewName,
FileUrl = Request.GetFileUrl(file.AttachmentType, fileNewName),
ThumbnailUrl = thumbnailUrl
});
//return new FilePathResult()
//{
// IsOk = false,
// ErrorMessage = "Error On Save"
//};
}
catch (Exception e)
{
LogHelper.WriteError(e);
//Console.WriteLine(e.Message);
return(new FilePathResult()
{
IsOk = false,
ErrorMessage = "Errow while uploading file"
});
}
}
catch (Exception e)
{
LogHelper.WriteError(e);
return(new FilePathResult()
{
IsOk = false,
ErrorMessage = e.ToString()
});
}
}
}
}
public async Task <IdResult> Submit(Models.Post item)
{
if (item == null)
{
return(new IdResult()
{
IsOk = false,
ErrorMessage = "No post info"
});
}
Common.Model.Post itemDb = null;
var dbUser = DbUser;
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
using (PostRepository _postRepository = new PostRepository(Context, dbUser, null))
using (UserContactRepository _userContactRepository = new UserContactRepository(Context, dbUser, null))
{
{
try
{
if (item.Id == Guid.Empty)
{
//if (item.SelectedContact != null)
//{
// var contactCircle = _userContactRepository.GetCircleByUsersPair(dbUser,
// item.SelectedContact.Id);
// if (contactCircle != null)
// {
// item.SelectedCircle = new Circle() { Id = contactCircle.Id };
// }
//}
itemDb = new Common.Model.Post()
{
Title = item.Title,
Type = item.Type,
CircleId = item.CircleId ?? item.SelectedCircle?.Id,
UserId = item.UserId ?? item.SelectedContact?.Id,
ParentId = item.ParentId
//LastUpdatedDate = DateTime.Now,
//LastUpdatedUserId = dbUser,
};
_postRepository.Create(itemDb);
}
else
{
itemDb = _postRepository.GetById(item.Id);
itemDb.Title = item.Title;
itemDb.Type = item.Type;
_postRepository.Update(itemDb);
}
Context.SaveChanges();
if (itemDb != null)
{
if (itemDb.Type == (int)PostTypes.Prompt)
{
if (itemDb.UserId.HasValue)
{
Utilities.AddNotification(dbUser, itemDb.UserId.Value, itemDb.Id, (int)NotificationTypes.NewPromptInCircle,
string.Format("You've got new Prompt"));
}
else if (itemDb.CircleId.HasValue)
{
var usersOfCircle = _userContactRepository.GetAllCircleUsers(itemDb.CircleId.Value);
if (usersOfCircle != null)
{
foreach (var userProfile in usersOfCircle)
{
Utilities.AddNotification(dbUser, userProfile.Id, itemDb.Id, (int)NotificationTypes.NewPromptInCircle, string.Format("You've got new Prompt"));
}
}
}
}
else if (itemDb.Type == (int)PostTypes.Reply && itemDb.ParentId.HasValue)
{
var parentPost = _postRepository.GetById(itemDb.ParentId.Value);
if (parentPost != null)
{
Utilities.AddNotification(dbUser, parentPost.CreatorId, parentPost.Id, (int)NotificationTypes.Reply,
string.Format("You've got new Reply on you post:{0}", parentPost.Title));
}
}
else if (itemDb.Type == (int)PostTypes.TellMeMore && itemDb.ParentId.HasValue)
{
var parentReplyPost = _postRepository.GetById(itemDb.ParentId.Value);
if (parentReplyPost != null && parentReplyPost.ParentId.HasValue)
{
var parentPost = _postRepository.GetById(parentReplyPost.ParentId.Value);
if (parentPost != null)
{
Utilities.AddNotification(dbUser, parentReplyPost.CreatorId, parentPost.Id, (int)NotificationTypes.TellMeMore,
string.Format("You've got TellMeMore on you reply in post:{0}", parentPost.Title));
}
}
}
transactionScope.Complete();
return(new IdResult()
{
IsOk = true,
Id = itemDb.Id
});
}
return(new IdResult()
{
IsOk = false,
ErrorMessage = "Error On Save"
});
}
catch (Exception e)
{
LogHelper.WriteError(e);
return(new IdResult()
{
IsOk = false,
ErrorMessage = e.ToString()
});
}
}
}
}
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));
}
public UserContactVersioningProxy(UserContactRepository userContactRepository, UserContactEqualityComparer userContactEqualityComparer, IDateTimeProvider dateTimeProvider)
{
m_userContactRepository = userContactRepository;
m_dateTimeProvider = dateTimeProvider;
m_userContactEqualityComparer = userContactEqualityComparer;
}
