public void UpdatePassword(IUnitOfWork uow, UserDO userDO, string password)
{
if (userDO != null)
{
uow.UserRepository.UpdateUserCredentials(userDO, password: password);
}
}
/// <summary>
/// Determines <see cref="CommunicationMode">communication mode</see> for user
/// </summary>
/// <param name="userDO">User</param>
/// <returns>Direct if the user has a booking request or a password. Otherwise, Delegate.</returns>
public CommunicationMode GetMode(UserDO userDO)
{
if (userDO.UserBookingRequests != null && userDO.UserBookingRequests.Any())
return CommunicationMode.Direct;
if(!String.IsNullOrEmpty(userDO.PasswordHash))
return CommunicationMode.Direct;
return CommunicationMode.Delegate;
}
public void Track(UserDO userDO, String eventName, String action, Dictionary<String, object> properties = null)
{
if (properties == null)
properties = new Dictionary<string, object>();
properties["Action"] = action;
Track(userDO, eventName, properties);
}
public void Identify(UserDO userDO)
{
var props = new Traits();
foreach (var prop in GetProperties(userDO))
props.Add(prop.Key, prop.Value);
Analytics.Client.Identify(userDO.Id, props);
}
public void Create(IUnitOfWork uow, UserDO submittedUserData, string role, bool sendEmail)
{
if (sendEmail)
{
new Email().SendUserSettingsNotification(uow, submittedUserData);
}
new Account().Register(uow, submittedUserData.EmailAddress.Address, submittedUserData.FirstName, submittedUserData.LastName, "test@1234", role);
}
public void Login(IUnitOfWork uow, UserDO userDO)
{
ClaimsIdentity identity = GetIdentity(uow, userDO);
HttpContext.Current.GetOwinContext().Authentication.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, identity);
ObjectFactory.GetInstance<ITracker>().Identify(userDO);
}
public ClaimsIdentity GetIdentity(IUnitOfWork uow, UserDO userDO)
{
var um = new KwasantUserManager(uow);
var identity = um.CreateIdentity(userDO, DefaultAuthenticationTypes.ApplicationCookie);
foreach (var roleId in userDO.Roles.Select(r => r.RoleId))
{
var role = uow.AspNetRolesRepository.GetByKey(roleId);
identity.AddClaim(new Claim(ClaimTypes.Role, role.Name));
}
return identity;
}
private Dictionary<String, object> GetProperties(UserDO userDO)
{
var user = new User();
return new Dictionary<string, object>
{
{"First Name", userDO.FirstName},
{"Last Name", userDO.LastName},
{"Username", userDO.UserName},
{"Email", userDO.EmailAddress.Address},
{"Delegate Account", user.GetMode(userDO) == CommunicationMode.Delegate }
};
}
public void Track(UserDO userDO, String eventName, Dictionary<String, object> properties = null)
{
var props = new Segment.Model.Properties();
foreach (var prop in GetProperties(userDO))
props.Add(prop.Key, prop.Value);
if (properties != null)
{
foreach (var prop in properties)
props[prop.Key] = prop.Value;
}
Analytics.Client.Track(userDO.Id, eventName, props);
}
//if we have a first name and last name, use them together
//else if we have a first name only, use that
//else if we have just an email address, use the portion preceding the @ unless there's a name
//else throw
public static string GetDisplayName(UserDO curUser)
{
string firstName = curUser.FirstName;
string lastName = curUser.LastName;
if (firstName != null)
{
if (lastName == null)
return firstName;
return firstName + " " + lastName;
}
EmailAddressDO curEmailAddress = curUser.EmailAddress;
if (curEmailAddress.Name != null)
return curEmailAddress.Name;
RegexUtilities.ValidateEmailAddress(curEmailAddress.Address);
return curEmailAddress.Address.Split(new[] {'@'})[0];
}
public void UpdateAnswerData(IUnitOfWork uow, NegotiationVM curNegotiationVM, UserDO curUserDO, Dictionary<QuestionDO, AnswerDO> questionAnswer )
{
//Here we add/update questions based on our proposed negotiation
foreach (var submittedQuestion in curNegotiationVM.Questions)
{
var currentSelectedAnswers = ExtractSelectedAnswers(uow, submittedQuestion, curUserDO, questionAnswer);
var previousQResponses = uow.QuestionResponseRepository.GetQuery()
.Where(qr =>
qr.Answer.QuestionID == submittedQuestion.Id &&
qr.UserID == curUserDO.Id).ToList();
var currentSelectedAnswerIDs = submittedQuestion.Answers.Where(a => a.Selected).Select(a => a.Id).ToList();
//First, remove old answers
foreach (
var previousQResponse in
previousQResponses.Where(
previousQResponse =>
!previousQResponse.AnswerID.HasValue ||
!currentSelectedAnswerIDs.Contains(previousQResponse.AnswerID.Value)))
{
uow.QuestionResponseRepository.Remove(previousQResponse);
}
var previousAnswerIds = previousQResponses.Select(a => a.AnswerID).ToList();
//Add new answers
foreach (var currentSelectedAnswer in
currentSelectedAnswers.Where(a => !previousAnswerIds.Contains(a.Id)))
{
var newAnswer = new QuestionResponseDO
{
Answer = currentSelectedAnswer,
UserID = curUserDO.Id
};
uow.QuestionResponseRepository.Add(newAnswer);
}
}
}
public void Create(IUnitOfWork uow, UserDO submittedUserData)
{
submittedUserData.State = UserState.Active;
submittedUserData.Id = Guid.NewGuid().ToString();
submittedUserData.UserName = submittedUserData.FirstName;
submittedUserData.EmailAddress = uow.EmailAddressRepository.GetOrCreateEmailAddress(submittedUserData.EmailAddress.Address);
submittedUserData.Roles.ToList().ForEach(e =>
uow.AspNetUserRolesRepository.Add(new AspNetUserRolesDO
{
RoleId = e.RoleId,
UserId = submittedUserData.Id
}));
submittedUserData.Roles.Clear();
uow.UserRepository.Add(submittedUserData);
uow.SaveChanges();
AlertManager.ExplicitCustomerCreated(submittedUserData.Id);
}
public void ReportUserRegistered(UserDO curUser)
{
using (var uow = ObjectFactory.GetInstance<IUnitOfWork>())
{
FactDO curFactDO = new FactDO
{
PrimaryCategory = "User",
SecondaryCategory = "",
Activity = "Registered",
CustomerId = curUser.Id,
ObjectId = null,
Data = string.Format("User registrated with :{0},", curUser.EmailAddress.Address)
//Data = "User registrated with " + curUser.EmailAddress.Address
};
Logger.GetLogger().Info(curFactDO.Data);
uow.FactRepository.Add(curFactDO);
uow.SaveChanges();
}
}
public LoginStatus Login(IUnitOfWork uow, UserDO userDO, string password, bool isPersistent)
{
LoginStatus curLogingStatus = LoginStatus.Successful;
var passwordHasher = new PasswordHasher();
if (passwordHasher.VerifyHashedPassword(userDO.PasswordHash, password) == PasswordVerificationResult.Success)
{
var securityServices = ObjectFactory.GetInstance<ISecurityServices>();
securityServices.Logout();
securityServices.Login(uow, userDO);
}
else
{
curLogingStatus = LoginStatus.InvalidCredential;
}
return curLogingStatus;
}
//this is called when a new customer is created, because the communication manager has subscribed to the alertCustomerCreated alert.
public void NewCustomerWorkflow(UserDO userDO)
{
ObjectFactory.GetInstance<ITracker>().Identify(userDO);
}
public string GetCRTemplate(UserDO curUserDO)
{
string templateName;
// Max Kostyrkin: currently User#GetMode returns Direct if user has a booking request or has a password, otherwise Delegate.
switch (_user.GetMode(curUserDO))
{
case CommunicationMode.Direct:
templateName = _configRepository.Get("CR_template_for_creator");
break;
case CommunicationMode.Delegate:
templateName = _configRepository.Get("CR_template_for_precustomer");
break;
case CommunicationMode.Precustomer:
templateName = _configRepository.Get("CR_template_for_precustomer");
break;
default:
throw new ArgumentOutOfRangeException();
}
return templateName;
}
private void AddNewTestCustomer(EmailAddressDO emailAddress)
{
using (var uow = ObjectFactory.GetInstance<IUnitOfWork>())
{
var fixture = new FixtureData(uow);
var outboundEmailDaemon = new OutboundEmail();
emailAddress.Recipients = new List<RecipientDO>()
{
new RecipientDO()
{
EmailAddress = Email.GenerateEmailAddress(uow, new MailAddress("*****@*****.**")),
EmailParticipantType = EmailParticipantType.To
}
};
uow.AspNetRolesRepository.Add(fixture.TestRole());
var u = new UserDO();
var user = new User();
UserDO currUserDO = new UserDO();
currUserDO.EmailAddress = emailAddress;
uow.UserRepository.Add(currUserDO);
}
}
public List<AnswerDO> ExtractSelectedAnswers(IUnitOfWork uow, NegotiationQuestionVM submittedQuestionData, UserDO curUserDO,
Dictionary<QuestionDO, AnswerDO> questionAnswer)
{
if (submittedQuestionData.Id == 0)
throw new HttpException(400, "Invalid parameter: Id of question cannot be 0.");
var questionDO = uow.QuestionRepository.GetByKey(submittedQuestionData.Id);
var currentSelectedAnswers = new List<AnswerDO>();
//Previous answers are read-only, we only allow updating of new answers
foreach (var submittedAnswerData in submittedQuestionData.Answers)
{
if (submittedAnswerData.Selected)
{
AnswerDO answerDO;
if (submittedAnswerData.Id == 0)
{
answerDO = new AnswerDO();
uow.AnswerRepository.Add(answerDO);
answerDO.Question = questionDO;
if (answerDO.AnswerStatus == 0)
answerDO.AnswerStatus = AnswerState.Proposed;
answerDO.Text = submittedAnswerData.Text;
answerDO.EventID = submittedAnswerData.EventID;
answerDO.UserID = curUserDO.Id;
}
else
{
answerDO = uow.AnswerRepository.GetByKey(submittedAnswerData.Id);
}
questionAnswer[questionDO] = answerDO;
currentSelectedAnswers.Add(answerDO);
}
}
return currentSelectedAnswers;
}
public void Update(IUnitOfWork uow, UserDO submittedUserData, UserDO existingUser)
{
existingUser.FirstName = submittedUserData.FirstName;
existingUser.LastName = submittedUserData.LastName;
//Remove old roles
foreach (var existingRole in existingUser.Roles.ToList())
{
if (!submittedUserData.Roles.Select(role => role.RoleId).Contains(existingRole.RoleId))
uow.AspNetUserRolesRepository.Remove(uow.AspNetUserRolesRepository.FindOne(e => e.RoleId == existingRole.RoleId && e.UserId == existingUser.Id));
}
//Add new roles
foreach (var newRole in submittedUserData.Roles)
{
if (!existingUser.Roles.Select(role => role.RoleId).Contains(newRole.RoleId))
uow.AspNetUserRolesRepository.Add(new AspNetUserRolesDO
{
RoleId = newRole.RoleId,
UserId = submittedUserData.Id
});
}
uow.SaveChanges();
}
public void Login(IUnitOfWork uow, UserDO userDO)
{
lock (_locker)
_currentLoggedInUser = userDO;
}
public void Logout()
{
lock (_locker)
_currentLoggedInUser = null;
}
private UserVM CreateUserVM(UserDO u, IUnitOfWork uow)
{
return new UserVM
{
Id = u.Id,
FirstName = u.FirstName,
LastName = u.LastName,
UserName = u.UserName,
EmailAddress = u.EmailAddress.Address,
Role = ConvertRolesToRoleString(uow.AspNetUserRolesRepository.GetRoles(u.Id).Select(r => r.Name).ToArray()),
Calendars = u.Calendars.Select(c => new UserCalendarVM { Id = c.Id, Name = c.Name }).ToList(),
EmailAddressID = u.EmailAddressID.Value,
Status = u.State.Value
};
}
