public void AssignMembershipToUser(int membershipOptionId, int?userId = null, PromoCode promoCode = null)
{
try
{
var membershipOption = _membershipOptionRepository.Find(membershipOptionId);
if (membershipOption == null)
{
_logger.Error($"MembershipService => AssignMembershipToUser => No MembershipOption with id {membershipOptionId} was found.");
throw new IndexOutOfRangeException("Invalid MembershipOptionId");
}
var userMembership = new UserMembership
{
UserId = userId ?? _authentication.CurrentUserId,
MembershipOptionId = membershipOptionId,
StartsOn = DateTime.Today,
EndsOn = membershipOption.IsAnnual ? DateTime.Today.AddYears(1) : DateTime.Today.AddMonths(1),
IsAutoRenew = true
};
_userMembershipRepository.Create(userMembership);
userMembership.User = _usersRepository.Find(userId ?? _authentication.CurrentUserId);
TerminateExistingMemberships(membershipOptionId);
}
catch (Exception ex)
{
_logger.Error($"MembershipService => AssignMembershipToUser => Assign Membership failed: {ex.GetFullErrorMessage()}");
throw ex;
}
}
public async Task <IdentityResult> AddUserAsync(string poolId, string userId)
{
try
{
Ensure.Argument.NotNull(userId);
Ensure.Argument.NotNullOrEmpty(poolId);
var membership = new UserMembership()
{
PoolId = poolId, UserId = userId
};
membership.UserRoles =
_db.Roles.Where(x => x.PoolId == poolId && x.IsDefault == true)
.Select(role => new UserRole()
{
UserId = userId,
RoleId = role.Id
}).ToList();
_db.UserMemberships.Add(membership);
await _db.SaveChangesAsync();
return(IdentityResult.Success);
}
catch (Exception ex)
{
return(IdentityResult.Failed(new IdentityError[] {
new IdentityError()
{
Description = ex.Message
}
}));
}
}
private void CreateNewUserRelationshipCompatibilityReading(UserMembership userMembership, PersonModel personModel1, PersonModel personModel2, bool isHideSexuality)
{
var userRelationshipCompatibilityReading = new UserRelationshipCompatibilityReading
{
FirstName = personModel1.Name,
FirstDateOfBirth = personModel1.DateOfBirth,
FirstGender = personModel1.Gender,
SecondName = personModel2.Name,
SecondDateOfBirth = personModel2.DateOfBirth,
SecondGender = personModel2.Gender,
UserId = _authentication.CurrentUserId,
UserMembershipId = userMembership.Id,
IsHideSexuality = isHideSexuality
};
if (userMembership.NumberOfRelationshipCompatibilityReadingsLeft <= 0)
{
var userCredit = _userCreditPacksRepository.Find(e => e.UserId == userMembership.UserId).FirstOrDefault();
if (userMembership.NumberOfCreditsLeft == 0 || userCredit == null)
{
_logger.Error($"MembershipService => CreateNewUserProfileReading => No User Credits were found for User {userMembership.UserId}.");
throw new Exception("No User Credits were found");
}
userRelationshipCompatibilityReading.UserCreditPackId = userCredit.Id;
}
_userRelationshipCompatibilityReadingsRepository.Create(userRelationshipCompatibilityReading);
}
private void CreateNewUserProfileReading(UserMembership userMembership, string name, DateTime dateOfBirth, EGender gender)
{
var userProfileReading = new UserProfileReading
{
FullName = name,
DateOfBirth = dateOfBirth,
Gender = gender,
UserId = userMembership.UserId,
UserMembershipId = userMembership.Id
};
if (userMembership.NumberOfProfileReadingsLeft == 0)
{
var userCredit = _userCreditPacksRepository.Find(e => e.UserId == userMembership.UserId).FirstOrDefault();
if (userMembership.NumberOfCreditsLeft == 0 || userCredit == null)
{
_logger.Error($"MembershipService => CreateNewUserProfileReading => Not enough Credits remaining for User {userMembership.UserId}.");
throw new Exception("Not enough credits remaining");
}
userProfileReading.UserCreditPackId = userCredit.Id;
}
_userProfileReadingsRepository.Create(userProfileReading);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new UserMembership {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
private void SendEmailToCustomer(UserMembership userMembership, Contact contact, PromoCode promoCode = null)
{
var template = Dictionary.NewMembershipThankYouEmail;
var title = TemplateProcessor.PopulateTemplate(Dictionary.ThankyouForSubscriptionEmailTitle, new
{
SubscriptionType = userMembership.MembershipOption.SubscriptionTypeNameLocal
});
if (contact != null && !contact.IsUnsubscribed)
{
_mailer.SendEmail(title, TemplateProcessor.PopulateTemplate(template, new
{
Title = title,
CustomerName = userMembership.User.FirstName,
SubscriptionType = userMembership.MembershipOption.SubscriptionTypeNameLocal,
TotalPrice = promoCode.FormattedPrice ?? userMembership.MembershipOption.FormattedPrice,
EndsOn = userMembership.EndsOn.ToLongDateString(),
NumberOfConsultations = userMembership.MembershipOption.NumberOfConsultations,
ImageUrl = _urlHelper.AbsoluteContent(_config.CompanyLogoUrl),
PrivacyPolicyLink = _urlHelper.AbsoluteAction("PrivacyPolicy", "Home"),
UnsubscribeLink = _urlHelper.AbsoluteAction("Unsubscribe", "Account", new { id = contact.Id }),
DateTime.Now.Year
}), userMembership.User.EmailAddress, userMembership.User.FirstName, _config.SupportEmailAddress,
_config.CompanyName);
}
}
private static void AddUserMembership(UserMembership userMembership)
{
bool membershipExists = Get(userMembership.user_id).Any(u => u.resource_id == userMembership.resource_id);
DbUtils.ConnectAndExecute(conn => {
var query = "INSERT INTO engine4_user_membership(resource_id,user_id,active,resource_approved,user_approved,message,description) " +
"VALUES (@resource_id,@user_id,@active,@resource_approved,@user_approved,@message,@description)";
if (membershipExists)
{
query = "UPDATE engine4_user_membership set active=active,resource_approved=@resource_approved,user_approved=@user_approved,message=@message,description=@description " +
"where resource_id=@resource_id AND user_id=@user_id";
}
var cmd = new MySqlCommand(query, conn);
cmd.Parameters.AddWithValue("resource_id", userMembership.resource_id);
cmd.Parameters.AddWithValue("user_id", userMembership.user_id);
cmd.Parameters.AddWithValue("active", userMembership.active ? 1:0);
cmd.Parameters.AddWithValue("resource_approved", userMembership.resource_approved?1:0);
cmd.Parameters.AddWithValue("user_approved", userMembership.user_approved?1:0);
cmd.Parameters.AddWithValue("message", userMembership.message);
cmd.Parameters.AddWithValue("description", userMembership.description);
var rc = cmd.ExecuteNonQuery();
return(0);
});
}
/// <summary>
/// Enables a user memberhip to a pool
/// </summary>
/// <param name="poolId">The unique id of the SecurityPool</param>
/// <param name="userId">The unique id of the User</param>
/// <returns>True if the operation succeeded, false if not</returns>
public async Task <bool> EnableUserAsync(string poolId, string userId)
{
Ensure.Argument.NotNullOrEmpty(poolId, "poolId");
Ensure.Argument.NotNullOrEmpty(userId, "userId");
var success = false;
var membership = new UserMembership();
membership.UserId = userId;
membership.PoolId = poolId;
membership.Disabled = false;
try
{
_db.UserMemberships.Attach(membership);
_db.UserMemberships.Update(membership);
await _db.SaveChangesAsync();
return(success = true);
}
catch (Exception error)
{
return(success);
}
}
public List <UserMembership> GetUserMembership()
{
var usersList = new List <UserMembership>();
DataSet ds = new DataSet();
string query = Resources.UserMembership;
try
{
ds = (DataSet)ExecuteQuery(query);
foreach (DataTable t in ds.Tables)
{
foreach (DataRow r in t.Rows)
{
UserMembership UM = new UserMembership();
UM.DBName = (String)r["DBname"];
UM.UserName = (String)r["UserName"];
UM.GroupName = (String)r["GroupName"];
UM.LoginName = (String)r["LoginName"];
UM.Def_DBName = r["DefDBName"] == DBNull.Value ? null : (String)r?["DefDBName"];
UM.Def_SchemaName = r["DefSchemaName"] == DBNull.Value ? null : (String)r?["DefSchemaName"];
usersList.Add(UM);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Exception catched: " + ex.Message);
throw;
//Console.WriteLine("Exception catched: " + ex.Message);
//DO2.Success = false;
}
return(usersList);
}
public static async Task <ClaimsIdentity> GenerateUserIdentityAsync(this UserMembership loggedUser, UserManager <UserMembership> manager)
{
// Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
var userIdentity = await manager.CreateIdentityAsync(loggedUser, DefaultAuthenticationTypes.ApplicationCookie);
// Add custom user claims here
return(userIdentity);
}
public UserMembership Insert(UserMembership obj)
{
using (InsightEntities db = new InsightEntities())
{
db.UserMembership.Add(obj);
db.SaveChanges();
return(obj);
}
}
public void CreateNewUser(string FullName, string Email, string AddUserRole)
{
try
{
NameSplit(FullName);
UserInfo oUser = new UserInfo();
oUser.PortalID = this.PortalId;
oUser.IsSuperUser = false;
oUser.FirstName = FirstName;
oUser.LastName = LastName;
oUser.Email = Email;
oUser.Username = Email;
oUser.DisplayName = FullName;
//Fill MINIMUM Profile Items (KEY PIECE)
oUser.Profile.PreferredLocale = PortalSettings.DefaultLanguage;
oUser.Profile.PreferredTimeZone = PortalSettings.TimeZone;
oUser.Profile.FirstName = oUser.FirstName;
oUser.Profile.LastName = oUser.LastName;
//Set Membership
UserMembership oNewMembership = new UserMembership(oUser);
oNewMembership.Approved = true;
oNewMembership.CreatedDate = System.DateTime.Now;
// oNewMembership.Email = oUser.Email;
oNewMembership.IsOnLine = false;
// oNewMembership.Username = oUser.Username;
oNewMembership.Password = GenerateRandomString(7);
//Bind membership to user
oUser.Membership = oNewMembership;
//Add the user, ensure it was successful
if (DotNetNuke.Security.Membership.UserCreateStatus.Success == UserController.CreateUser(ref oUser))
{
//Add Role if passed something from module settings
if (AddUserRole.Length > 0)
{
DotNetNuke.Security.Roles.RoleController rc = new DotNetNuke.Security.Roles.RoleController();
//retrieve role
string groupName = AddUserRole;
DotNetNuke.Security.Roles.RoleInfo ri = rc.GetRoleByName(PortalId, groupName);
rc.AddUserRole(this.PortalId, oUser.UserID, ri.RoleID, Null.NullDate);
}
}
}
catch (Exception ex)
{
Exceptions.ProcessModuleLoadException(this, ex);
}
}
private void ProductResolver(PurchaseOrder purchaseOrder, PurchaseOrderLine poLineResult)
{
var productResult = _productService.GetProduct(poLineResult.ProductId);
if (productResult == null)
{
throw new ArgumentNullException(nameof(productResult));
}
var uprofile = _userprofileService.GetUserprofile(purchaseOrder.UserProfileId);
uprofile.UserMemberships = new List <UserMembership>();
// BR1.If the purchase order contains a membership, it should be activated in the customer account immediately.
if (productResult.ProductForm == RefProductForm.Membership)
{
// Activate the membership and assign membership value
// Should check to see if there is already a membership available of the Membership category, if so update that
var userMembership = new UserMembership
{
ProductId = productResult.Id,
UserProfileId = purchaseOrder.UserProfileId,
MembershipInitial = productResult.ProductMembershipValue,
MembershipRemaining = productResult.ProductMembershipValue,
MembershipCategory = productResult.ProductCategory,
DateAdded = DateTime.Now,
DateModified = DateTime.Now
};
_userMembershipService.AddUserMembership(userMembership);
//uprofile.UserMemberships.Add(userMembership);
//_userprofileService.UpdateUserprofile(uprofile.Id, uprofile);
}
else if (productResult.ProductForm == RefProductForm.Physical)
{
// BR2. If the purchase order contains a physical product, a shipping slip should be generated.
// probably would make more sense to check for a userShipment and see whats its status is, if unshipped update.... but again brevity.
var poShip = new PurchaseOrderShipment
{
PurchaseOrderId = purchaseOrder.Id,
ShipmentStatus = "Shipping Slip Created",
Weight = productResult.Weight,
TrackingNumber = ShippingLabelGenerator.GenerateShippingLabel(),
Items = 1,
DateAdded = DateTime.Now,
DateModified = DateTime.Now
};
_purchaseOrderShipmentService.AddPurchaseOrderShipment(poShip);
//purchaseOrder.PurchaseOrderShipments.Add(poShip);
//_purchaseOrderService.UpdatePurchaseOrder(purchaseOrder.Id, purchaseOrder);
}
}
public static void AddUserFreindRequest(uint userId, uint friendId)
{
UserMembership um = new UserMembership();
um.resource_id = friendId;
um.user_id = userId;
um.active = false; // ;
um.resource_approved = false; // wait for approval
um.user_approved = true;
AddUserMembership(um);
}
private int GetNumberOfCreditsLeft(UserMembership userMembership)
{
var creditPacks = _userCreditPacksRepository.Find(e => e.UserId == userMembership.UserId);
var creditPackIds = creditPacks.Select(c => c.Id);
var numberOfUsedCredits = (int?)0;
//_userProfileReadingsRepository.Find(e => creditPackIds.Contains(e.UserCreditPackId ?? 0))?.Count() +
//_userRelationshipCompatibilityReadingsRepository.Find(e => creditPackIds.Contains(e.UserCreditPackId ?? 0))?.Count();
var totalCredits = creditPacks.Any() ? creditPacks.Sum(e => e.NumberOfCredits) : 0;
return(totalCredits - numberOfUsedCredits ?? 0);
}
public MembershipModel(int userId, MembershipOption membershipOption, UserMembership activeUserMembership = null)
{
MembershipOption = membershipOption;
ActiveUserMembership = activeUserMembership;
UserId = userId;
if (MembershipOption != null)
{
MembershipOption.PriceIncludingDiscount = MembershipOption.Price - (ActiveUserMembership?.CostOfRemainingActiveSubscription ?? 0);
}
}
public ActionResult Login(UserMembership us)
{
bool isValid = db.Users.Any(x => x.Username == us.Username && x.Password == us.Password);
if (isValid)
{
FormsAuthentication.SetAuthCookie(us.Username, false);
return(RedirectToAction("Index", "Posts"));
}
ModelState.AddModelError("", "Invalid Username and Password");
return(View());
}
/// <summary>
/// GetUsetTaskComments
/// </summary>
/// <param name="taskId"></param>
/// <returns></returns>
public List <WorkflowComment> GetWorkflowComments(ContextEnum context, int contextContentId)
{
List <WorkflowComment> workflowComments = eCollabroDbContext.Repository <WorkflowComment>().Query().Filter(qry => qry.ContextId.Equals(contextContentId) && qry.ContextId.Equals((int)context)).Get().ToList();
SecurityManager securityManager = new SecurityManager();
List <UserMembership> users = securityManager.GetUsers(workflowComments.Select(fld => fld.CreatedById).ToList());
foreach (WorkflowComment comment in workflowComments)
{
UserMembership user = users.Where(qry => qry.UserId.Equals(comment.CreatedById)).FirstOrDefault();
comment.CreatedBy = user == null ? "Unknown" : user.UserName;
comment.TimeInterval = CommonFunctions.GetTimeInterval(comment.CreatedOn);
}
return(workflowComments);
}
public async Task <bool> SaveMemberShipPlan(UserMembership membership)
{
try
{
this.therapistContext.UserMembership.Add(membership);
await this.therapistContext.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
throw;
}
}
/// <summary>
/// Return true if user have phone number with his membership, otherwise return false.
/// </summary>
/// <param name="loggedUser"></param>
/// <returns></returns>
public static bool HasPhoneNumber(this UserMembership loggedUser)
{
const string unauthenticatedUser = "******";
const string noUserProfile = "User do not have a profile associate with his membership. Cannot proceed to verification.";
if (loggedUser == null)
{
throw new NullReferenceException(unauthenticatedUser);
}
if (loggedUser.UserProfile == null)
{
throw new NullReferenceException(noUserProfile);
}
return(loggedUser.UserProfile.PhoneNumbers.Count() > 0);
}
private void SendEmailToVibrantHealth(UserMembership userMembership, PromoCode promoCode)
{
var template = Dictionary.MembershipCreatedEmail;
var title = "We have received a new subscription!";
_mailer.SendEmail(title, TemplateProcessor.PopulateTemplate(template, new
{
Title = title,
Customer = userMembership.User.FullName,
CustomerEmail = userMembership.User.EmailAddress,
SubscriptionType = userMembership.MembershipOption.SubscriptionTypeNameLocal,
TotalPrice = promoCode?.FormattedPrice ?? userMembership.MembershipOption.FormattedPrice,
LinkToSummary = _urlHelper.AbsoluteAction("Index", "UserMemberships"),
Company = _config.CompanyName,
ImageUrl = _urlHelper.AbsoluteContent(_config.CompanyLogoUrl)
}), _config.SupportEmailAddress, _config.CompanyName, _config.SupportEmailAddress, _config.CompanyName);
}
/// <summary>
/// GeneratePasswordResetToken
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
public ServiceResponse <UserTokenVerificationDC> GeneratePasswordResetToken(string username)
{
ServiceResponse <UserTokenVerificationDC> generatePasswordResetTokenResponse = new ServiceResponse <UserTokenVerificationDC>();
try
{
SetContext();
UserMembership userMembership = _securityManager.ResetPassword(username); //step 1
generatePasswordResetTokenResponse.Result = new UserTokenVerificationDC();
generatePasswordResetTokenResponse.Result.UserName = userMembership.UserName;
generatePasswordResetTokenResponse.Result.Token = userMembership.PasswordVerificationToken;
}
catch (Exception ex)
{
HandleError(ex, generatePasswordResetTokenResponse);
}
return(generatePasswordResetTokenResponse);
}
/// <summary>
/// eCollabroSetup
/// </summary>
/// <param name="serviceRequest"></param>
/// <returns></returns>
public ServiceResponse eCollabroSetup(RegisterDC register)
{
ServiceResponse eCollabroSetupResponse = new ServiceResponse();
try
{
UserMembership userMembership = new UserMembership();
userMembership.UserName = register.UserName;
userMembership.Password = register.Password;
userMembership.Email = register.Email;
_setupManager.SetupEcollabro(userMembership);
}
catch (Exception ex)
{
HandleError(ex, eCollabroSetupResponse);
}
return(eCollabroSetupResponse);
}
private static void CreateUser(string userName, int age, int membershipId)
{
var userNameResult = UserName.Create(userName);
var userAgeResult = UserAge.Create(age);
var userMembership = UserMembership.Create(membershipId);
var result = Result.Combine(userNameResult, userAgeResult, userMembership);
if (result.IsFailure)
{
Console.WriteLine(result.ErrorMsg);
Console.WriteLine("Try again.");
return;
}
var createdId = Database.CreateUser(userNameResult.Value, userAgeResult.Value, userMembership.Value);
Console.WriteLine($"Created with id: {createdId}");
}
public void ProcessPurchase(PurchaseModel purchaseModel, int?userId = null, PromoCode promoCode = null)
{
try
{
var membershipOptionId = purchaseModel.ItemId;
if (membershipOptionId <= 0)
{
return;
}
var membershipOption = _membershipOptionRepository.Find(membershipOptionId);
if (membershipOption == null)
{
_logger.Error($"MembershipService => ProcessPurchase => No MembershipOption with id {membershipOptionId} was found.");
throw new IndexOutOfRangeException("Invalid MembershipOptionId");
}
var userMembership = new UserMembership
{
UserId = userId ?? _authentication.CurrentUserId,
MembershipOptionId = membershipOptionId,
StartsOn = DateTime.Today,
EndsOn = membershipOption.IsAnnual ? DateTime.Today.AddYears(1) : DateTime.Today.AddMonths(1),
IsAutoRenew = true
};
_userMembershipRepository.Create(userMembership);
userMembership.User = _usersRepository.Find(userId ?? _authentication.CurrentUserId);
TerminateExistingMemberships(membershipOptionId);
var contact = _contactService.Find(purchaseModel.ContactId);
SendEmailToNineStar(userMembership, promoCode);
SendEmailToCustomer(userMembership, contact, promoCode);
}
catch (Exception ex)
{
_logger.Error($"MembershipService => ProcessPurchase => Purchase failed: {ex.GetFullErrorMessage()}");
SendEmailToNineStarAboutFailure(purchaseModel, ex.GetFullErrorMessage());
throw ex;
}
}
public void GetMembershipModel_CanUpgradeOne_AndSwitchOne()
{
AuthenticateUser();
var startsOn = DateTime.Today.AddDays(-7);
var scheduledStartsOn = startsOn.AddMonths(1).AddDays(5);
var scheduledUserMembership = new UserMembership
{
Id = 8,
UserId = _userId,
MembershipOptionId = _standardMonthlyMembership.Id,
MembershipOption = _standardMonthlyMembership,
StartsOn = scheduledStartsOn,
EndsOn = scheduledStartsOn.AddMonths(1),
IsAutoRenew = true
};
var userMembershipModels = new List <UserMembership>
{
new UserMembership
{
Id = 7,
UserId = _userId,
MembershipOptionId = _platinumMonthlyMembership.Id,
MembershipOption = _platinumMonthlyMembership,
StartsOn = startsOn,
EndsOn = startsOn.AddMonths(1)
},
scheduledUserMembership
};
_userMembershipRepository.Setup(_ => _.Find(It.IsAny <System.Linq.Expressions.Expression <Func <UserMembership, bool> > >()))
.Returns(userMembershipModels.AsQueryable());
var model = _Membershipservice.GetMembershipViewModel();
Assert.Equal(1, _Membershipservice.GetActiveUserMemberships().Count);
Assert.Equal(userMembershipModels.First(), _Membershipservice.GetActiveUserMembership());
Assert.Equal(0, model.MembershipModels.Count(_ => _.IsSelected));
Assert.Equal(1, model.MembershipModels.Count(_ => _.IsUpgrade));
Assert.Equal(1, model.MembershipModels.Count(_ => _.IsSubscribed));
Assert.Equal(1, model.MembershipModels.Count(_ => _.IsSelectable));
Assert.Equal(7, model.MembershipModels.First().ActiveUserMembershipId);
}
/// <summary>
/// CreateAccount
/// </summary>
/// <param name="registerAccount"></param>
/// <returns></returns>
public ServiceResponse CreateAccount(RegisterDC registerAccount)
{
ServiceResponse createAccountResponse = new ServiceResponse();
try
{
SetContext();
UserMembership userMembership = new UserMembership();
userMembership.UserName = registerAccount.UserName;
userMembership.Password = registerAccount.Password;
userMembership.Email = registerAccount.Email;
_securityManager.CreateAccount(userMembership);
}
catch (Exception ex)
{
HandleError(ex, createAccountResponse);
}
return(createAccountResponse);
}
/// <summary>
/// SaveSiteCollectionAdmin
/// </summary>
/// <param name="username"></param>
public void SaveSiteCollectionAdmin(string username)
{
CheckSiteCollectionAdminPermission(UserContextDetails.UserId);
UserMembership user = _securityManager.FindUser(username);
SiteCollectionAdmin siteCollectionAdmin = eCollabroDbContext.Repository <SiteCollectionAdmin>().Query().Filter(qry => qry.UserId.Equals(user.UserId)).Get().FirstOrDefault();
if (siteCollectionAdmin != null)
{
throw new BusinessException(_coreValidationResourceManager.GetString(CoreValidationMessagesConstants.UserAlreadyExist), CoreValidationMessagesConstants.UserAlreadyExist);
}
else
{
siteCollectionAdmin = new SiteCollectionAdmin();
siteCollectionAdmin.CreatedById = UserContextDetails.UserId;
siteCollectionAdmin.CreatedOn = DateTime.UtcNow;
siteCollectionAdmin.UserId = user.UserId;
eCollabroDbContext.Repository <SiteCollectionAdmin>().Insert(siteCollectionAdmin);
eCollabroDbContext.Save();
}
}
public async Task <IdentityResult> UpdateUserAsync(string poolId, UserMembership user)
{
try
{
_db.UserMemberships.Attach(user);
_db.UserMemberships.Update(user);
await _db.SaveChangesAsync();
return(IdentityResult.Success);
}
catch (Exception ex)
{
return(IdentityResult.Failed(new IdentityError[] {
new IdentityError()
{
Description = ex.Message
}
}));
}
}
/// <summary>
/// GetUser
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public ServiceResponse <UserDetailDC> GetUser(int userId)
{
ServiceResponse <UserDetailDC> userResponse = new ServiceResponse <UserDetailDC>();
try
{
SetContext();
UserMembership user = _securityManager.GetUser(userId);
userResponse.Result = Mapper.Map <UserMembership, UserDetailDC>(user);
userResponse.Result.UserRoles = new List <RoleDC>();
foreach (UserRole userRole in user.UserRoles)
{
userResponse.Result.UserRoles.Add(Mapper.Map <Role, RoleDC>(userRole.Role));
}
}
catch (Exception ex)
{
HandleError(ex, userResponse);
}
return(userResponse);
}
