private static string GetExternalIdentity(ExternalClientContext externalClientContext, MailboxSession session)
{
FreeBusyPermission.SecurityTracer.TraceDebug <object, ExternalClientContext, IExchangePrincipal>(0L, "{0}: searching for external identity for caller {1} in mailbox {2}", TraceContext.Get(), externalClientContext, session.MailboxOwner);
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
PersonalClientContext personalClientContext = externalClientContext as PersonalClientContext;
if (personalClientContext != null)
{
using (ExternalUserCollection externalUsers = session.GetExternalUsers())
{
ExternalUser externalUser = externalUsers.FindExternalUser(personalClientContext.ExternalId.ToString());
if (externalUser != null)
{
string text = externalUser.Sid.ToString();
FreeBusyPermission.SecurityTracer.TraceDebug <object, string>(0L, "{0}: found personal client context from external identity: {1}", TraceContext.Get(), text);
return(text);
}
}
}
}
finally
{
stopwatch.Stop();
PerformanceCounters.AverageExternalAuthenticationIdentityMappingTime.IncrementBy(stopwatch.ElapsedTicks);
PerformanceCounters.AverageExternalAuthenticationIdentityMappingTimeBase.Increment();
}
return(null);
}
// GET: ExternalUser/Edit/5
public async Task <ActionResult> Edit(int id)
{
InitializeServiceClient();
HttpResponseMessage orgResponse = await client.PostAsJsonAsync("ExternalUser/GetAllOrganizations", req);
ViewBag.lstOrganizations = await orgResponse.Content.ReadAsAsync <List <Organization> >();
HttpResponseMessage groupResponse = await client.PostAsJsonAsync("ExternalUser/GetAllUserGroups", req);
ViewBag.lstGroups = await groupResponse.Content.ReadAsAsync <List <UserGroup> >();
HttpResponseMessage skillResponse = await client.PostAsJsonAsync("Skill/GetAllSkills", req);
ViewBag.Skills = await skillResponse.Content.ReadAsAsync <List <Skill> >();
HttpResponseMessage competencyResponse = await client.PostAsJsonAsync("Competency/GetAllCompetenceList", req);
ViewBag.CompetenceList = await competencyResponse.Content.ReadAsAsync <List <Competence> >(); //List of copetency levels
HttpResponseMessage geoResponse = await client.PostAsJsonAsync("Geo/GetAllGEOs", req);
ViewBag.GEOs = await geoResponse.Content.ReadAsAsync <List <GEO> >();
HttpResponseMessage roleResponse = await client.PostAsJsonAsync("User/GetAllRoles", req);
ViewBag.Roles = await roleResponse.Content.ReadAsAsync <List <Role> >();
HttpResponseMessage externalResponse = await client.PostAsJsonAsync("ExternalUser/GetAllExternalUsers", req);
List <ExternalUser> externalUsers = await externalResponse.Content.ReadAsAsync <List <ExternalUser> >();
ExternalUser user = externalUsers.Where(e => e.ID == id).FirstOrDefault();
return(View(user));
}
// GET: ExternalUser/Create
public async Task <ActionResult> Create()
{
InitializeServiceClient();
ExternalUser extUser = new ExternalUser();
HttpResponseMessage orgResponse = await client.PostAsJsonAsync("ExternalUser/GetAllOrganizations", req);
ViewBag.lstOrganizations = await orgResponse.Content.ReadAsAsync <List <Organization> >();
HttpResponseMessage groupResponse = await client.PostAsJsonAsync("ExternalUser/GetAllUserGroups", req);
ViewBag.lstGroups = await groupResponse.Content.ReadAsAsync <List <UserGroup> >();
HttpResponseMessage skillResponse = await client.PostAsJsonAsync("Skill/GetAllSkills", req);
ViewBag.Skills = await skillResponse.Content.ReadAsAsync <List <Skill> >();
HttpResponseMessage competencyResponse = await client.PostAsJsonAsync("Competency/GetAllCompetenceList", req);
ViewBag.CompetenceList = await competencyResponse.Content.ReadAsAsync <List <Competence> >(); //List of copetency levels
HttpResponseMessage geoResponse = await client.PostAsJsonAsync("Geo/GetAllGEOs", req);
ViewBag.GEOs = await geoResponse.Content.ReadAsAsync <List <GEO> >();
HttpResponseMessage roleResponse = await client.PostAsJsonAsync("User/GetAllRoles", req);
ViewBag.Roles = await roleResponse.Content.ReadAsAsync <List <Role> >();
return(View(extUser));
}
private async Task AddExtUser(User user, UserDomainsEnum userDomainEnum, string externalUserId)
{
var userDomainsTable = MobileService.GetTable <UserDomain>();
var userDomains = await userDomainsTable.ToCollectionAsync();
var domain = userDomains.SingleOrDefault(d => d.DomainKey == (int)userDomainEnum);
if (domain != null)
{
var externalUserstable = MobileService.GetTable <ExternalUser>();
var externalUsers = await externalUserstable.ToCollectionAsync();
var extUsers = externalUsers.Where(eu => eu.UserId == user.Id && eu.UserDomainId == domain.Id);
if (extUsers.SingleOrDefault() == null)
{
ExternalUser extUser = new ExternalUser()
{
Id = Guid.NewGuid().ToString(),
UserId = user.Id,
ExternalUserId = externalUserId,
UserDomainId = domain.Id
};
await externalUserstable.InsertAsync(extUser);
}
}
}
/// <summary>
/// Adds externalUser into user async
/// </summary>
/// <param name="externalUser"></param>
/// <param name="userUid"></param>
/// <returns></returns>
public async Task AddExternalUserIntoUserAsync(ExternalUser externalUser, Guid userUid) =>
await _users.UpdateOneAsync(Builders <DbUser> .Filter.Eq(v => v.Id, userUid.ToString()),
Builders <DbUser> .Update.AddToSet(items => items.ExternalUsers, externalUser.ToDbExternalUser()),
new UpdateOptions()
{
IsUpsert = true
});
private bool PreMembershipUpdate()
{
this.recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(false, ConsistencyMode.IgnoreInvalid, this.mailboxSession.GetADSessionSettings(), 106, "PreMembershipUpdate", "f:\\15.00.1497\\sources\\dev\\UnifiedGroups\\src\\UnifiedGroups\\GroupMailboxAccessLayer\\Commands\\GroupMailboxMembershipUpdater.cs");
this.groupObject = this.recipientSession.FindADUserByObjectId(this.mailboxSession.MailboxOwner.ObjectId);
if (this.groupObject == null)
{
GroupMailboxMembershipUpdater.Tracer.TraceError <string>((long)this.GetHashCode(), "PreMembershipUpdate: Unable to locate the AD object for the group mailbox {0} successfully", this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString());
return(false);
}
if (this.groupObject.RecipientTypeDetails != RecipientTypeDetails.GroupMailbox)
{
GroupMailboxMembershipUpdater.Tracer.TraceError <string>((long)this.GetHashCode(), "PreMembershipUpdate: The mailbox {0} is not of type group mailbox", this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString());
return(false);
}
GroupMailboxMembershipUpdater.Tracer.TraceDebug <string>((long)this.GetHashCode(), "PreMembershipUpdate: Located the AD object of the group mailbox {0} successfully", this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString());
this.previousExternalMemberUser = new ExternalUser(this.mailboxSession.DisplayName, this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString(), SmtpAddress.Parse(this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString()), GroupMailboxMembershipUpdater.EarlierGroupMailboxMemberAccessSecurityIdentifier);
this.currentExternalMemberUser = ExternalUser.CreateExternalUserForGroupMailbox(this.mailboxSession.DisplayName, "Member@local", this.mailboxSession.MailboxGuid, SecurityIdentity.GroupMailboxMemberType.Member);
this.currentExternalOwnerUser = ExternalUser.CreateExternalUserForGroupMailbox(this.mailboxSession.DisplayName, "Owner@local", this.mailboxSession.MailboxGuid, SecurityIdentity.GroupMailboxMemberType.Owner);
using (ExternalUserCollection externalUsers = this.mailboxSession.GetExternalUsers())
{
if (!this.AddToExternalUserCollection(externalUsers, this.previousExternalMemberUser) || !this.AddToExternalUserCollection(externalUsers, this.currentExternalMemberUser) || !this.AddToExternalUserCollection(externalUsers, this.currentExternalOwnerUser))
{
GroupMailboxMembershipUpdater.Tracer.TraceError <string>((long)this.GetHashCode(), "PreMembershipUpdate: Unable to update external user collection to the group mailbox {0} successfully", this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString());
return(false);
}
GroupMailboxMembershipUpdater.Tracer.TraceDebug <string>((long)this.GetHashCode(), "PreMembershipUpdate: Updated external user collection of the group mailbox {0} successfully", this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString());
}
return(true);
}
public async Task InsertUser(User user, string extUserId)
{
if (await EnsureLogin() && !string.IsNullOrWhiteSpace(extUserId))
{
var userInUser =
await MobileService.GetTable <User>().Where(u => u.Email == user.Email).ToCollectionAsync();
if (userInUser.SingleOrDefault() == null)
{
await MobileService.GetTable <User>().InsertAsync(user);
}
else
{
user = userInUser.Single();
}
//await table.InsertAsync(user);
ExternalUser externalUser = new ExternalUser()
{
Id = Guid.NewGuid().ToString(),
UserId = user.Id,
ExternalUserId = extUserId,
UserDomainId =
(await
MobileService.GetTable <UserDomain>()
.Where(u => u.DomainKey == (int)UserDomainEnum.Microsoft)
.ToCollectionAsync()).Single().Id
};
await AddExternalUser(externalUser);
await AddUserGroup(user);
}
}
public IActionResult Post([FromBody] ExternalUser externalUser)
{
int idUser = 0;
if (!ModelState.IsValid)
{
return(BadRequest());
}
using (var transaction = new TransactionScope())
{
try
{
HashSalt salt = new HashSalt();
salt = PasswordUtil.GenerateSaltedHash(32, externalUser.Password);
externalUser.Password = salt.Hash;
externalUser.Help = salt.Salt;
idUser = _unitOfWork.ExternalUser.Insert(externalUser);
transaction.Complete();
}
catch (Exception ex)
{
transaction.Dispose();
return(StatusCode(500, "Internal server error: " + ex.Message));
}
}
return(Ok(idUser));
}
public static User ToUser(ExternalUser externalUser)
{
var user = new User();
ExpressionMapper.PopulatePropertyAndSpecifiedField(() => user.Forename, externalUser.Forename);
return(user);
}
public async Task <ActionResult> UpdatePassword(ExternalUser model)
{
InitializeServiceClient();
//if (!ModelState.IsValid)
//{
// return View(model);
//}
var user = await UserManager.FindByNameAsync(model.UserName);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction("UpdatePassword", "Index"));
}
var token = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
var result = await UserManager.ResetPasswordAsync(user.Id, token, model.Password);
//var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
if (result.Succeeded)
{
TempData["msg"] = "Update Successful";
ExternalUserRequest externalUser = new ExternalUserRequest();
externalUser.ClientInfo = req.ClientInfo;
externalUser.UserName = model.UserName;
externalUser.Password = model.Password;
HttpResponseMessage response = await client.PostAsJsonAsync("ExternalUser/SendExternalUserPassword", externalUser);
bool resultsendmail = await response.Content.ReadAsAsync <bool>();
return(View(model));
}
AddErrors(result);
return(View());
}
public bool Authorized()
{
if (_cachedUser != null)
{
return(true);
}
var ticketToken = GetRequestTicketToken();
if (ticketToken == null || ticketToken.Length < TOKEN_LENTH)
{
return(false);
}
var token = ticketToken.Substring(TOKEN_LENTH);
if (_oAuthProvider.ValidateTokenRequest(token))
{
return(true);
}
var ticket = ticketToken.Substring(0, TOKEN_LENTH);
var exUser = GetAuthenticatedUserByTicket(ticket);
if (exUser == null || !exUser.AccessToken.Equals(token, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
_oAuthProvider.ReplaceToken(30, exUser.AccessToken, exUser.Id.ToString());
_cachedUser = exUser;
return(true);
}
public static void MetaExternalUserListUpsert(this FolderModel folder, ExternalUser externalUser, string metadataKeyLocation)
{
var externalUsers = folder.MetaExternalUserListRead(metadataKeyLocation);
externalUsers.RemoveAll(r => r.Email?.ToLower() == externalUser.Email?.ToLower());
externalUsers.Add(externalUser);
folder.MetaExternalUserListWrite(externalUsers, metadataKeyLocation);
}
public virtual void Update(ExternalUser entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
_externalUserRepository.Update(entity);
}
public void WhenANewExternalUserIsAddedWithCustomPropertySetTo(string user, string customPropertyName, string customPropertyValue)
{
ExternalUser externalUser = GetExternalUser(user);
var customProperties = new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>(customPropertyName, customPropertyValue)
};
Try(() => UserService.AddUser(externalUser.accountName, externalUser.accountType, externalUser.displayName, externalUser.memberOfGroups, customProperties));
}
public void GivenExternalUserIsMemberOfFollowingGroups(string userName, Table table)
{
ExternalUser user = GetExternalUser(userName);
foreach (var row in table.Rows)
{
user.memberOfGroups.Add(row["Group"]);
}
}
private MailboxFolderUserId(ExternalUser externalUser)
{
if (externalUser == null)
{
throw new ArgumentNullException("externalUser");
}
this.userType = MailboxFolderUserId.MailboxFolderUserType.External;
this.smtpAddress = externalUser.SmtpAddress;
this.externalUser = externalUser;
}
public async Task <ActionResult> ChangePassword(int id)
{
InitializeServiceClient();
HttpResponseMessage externalResponse = await client.PostAsJsonAsync("ExternalUser/GetAllExternalUsers", req);
List <ExternalUser> externalUsers = await externalResponse.Content.ReadAsAsync <List <ExternalUser> >();
ExternalUser user = externalUsers.Where(e => e.ID == id).FirstOrDefault();
return(View(user));
}
public async Task <IActionResult> CreateExternalUser(RegistrationViewModel vm)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = vm.NationalId,
Email = vm.Email,
PhoneNumber = vm.PhoneNumber,
};
var result = await _userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
var externalUser = new ExternalUser
{
UserId = user.Id,
UserDetails = new Person
{
Names = vm.Names.ToUpper(),
Surname = vm.Surname.ToUpper(),
NationalId = vm.NationalId,
Address = new Address
{
ResidentialAddress = vm.ResidentialAddress.ToUpper(),
City = vm.City.ToUpper(),
Country = vm.Country,
}
}
};
_db.ExternalUsers.Add(externalUser);
var externalPolicy = new ExternalPolicy
{
Value = "General",
ExternalUser = externalUser
};
_db.ExternalPolicies.Add(externalPolicy);
_db.SaveChanges();
if (!await _roleManager.RoleExistsAsync("External"))
{
await CreateRole("External");
}
await _userManager.AddToRoleAsync(user, "External");
return(View());
}
AddErrors(result);
}
return(View(vm));
}
public virtual void Delete(ExternalUser entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
entity.User.Deleted = true;
Update(entity);
this._externalUserRepository.Delete(entity);
}
/// <summary>
/// Gets user by external user async
/// </summary>
/// <param name="externalUser"></param>
/// <returns></returns>
public async Task <User> GetUserByExternalUserAsync(ExternalUser externalUser)
{
var stringBuilder = new StringBuilder();
stringBuilder.Append("{");
stringBuilder.Append("\"externalUsers.identifier\": ");
stringBuilder.Append($"\"{externalUser.Identifier}\", ");
stringBuilder.Append("\"externalUsers.provider\": ");
stringBuilder.Append($"{(int)externalUser.Provider} ");
stringBuilder.Append("}");
return(await GetUserAsync(stringBuilder.ToString()));
}
public void ToUser_PopulatedExternalUser_UserPropertiesMapped()
{
var expectedUser = new ExternalUser
{
Forename = "Tarquin"
};
User result = UserMapper.ToUser(expectedUser);
Assert.Equal(expectedUser.Forename, result.Forename);
Assert.True(result.ForenameSpecified);
}
internal async System.Threading.Tasks.Task <ExternalUser> AutoProvisionUserAsync(string provider, string providerUserId, IEnumerable <Claim> claims)
{
var user = _applicationDbContext.ExternalUsers.Where(c => c.ExternalProvider == provider && c.ProviderUserId == providerUserId).FirstOrDefault();
if (user == null)
{
string email = claims.ToList()[4].Value;
ApplicationUser appUser;
// first user, will be admin
if (_applicationDbContext.ExternalUsers.Count() == 0)
{
if ((appUser = _applicationDbContext.Users.Where(c => c.UserName == "admin").FirstOrDefault()) == null)
{
//admin
var adminUserApp = new ApplicationUser
{
UserName = "******",
Email = email
};
adminUserApp.Id = "admin";
var result3 = await _userManager.CreateAsync(adminUserApp, "111111");
}
//appUser = _applicationDbContext.Users.Where(c => c.UserName == "admin").FirstOrDefault();
}
else
{
appUser = new ApplicationUser
{
UserName = claims.ToList()[4].Value.Substring(0, email.IndexOf('@')),
Email = email
};
appUser = _applicationDbContext.Users.Add(appUser).Entity;
}
ExternalUser newUser = new ExternalUser
{
ExternalProvider = provider,
ProviderUserId = providerUserId,
Provider = provider,
Email = email,
User = appUser
};
user = _applicationDbContext.ExternalUsers.Add(newUser).Entity;
_applicationDbContext.SaveChanges();
}
return(user);
}
public void GivenThereAreFollowingExternalUsers(Table table)
{
foreach (var row in table.Rows)
{
var externalUser = new ExternalUser
{
userName = row["User name"],
displayName = row["Display name"],
accountName = row["Account name"],
accountType = ResolveAccountType(row["Account type"])
};
externalUsers.Add(externalUser);
}
}
public string RefreshToken(int expireTime, ExternalUser exUser)
{
if (exUser == null)
{
throw new ArgumentNullException(nameof(exUser));
}
var oauthToken = _oAuthProvider.RefreshToken(expireTime: expireTime, identity: exUser.Id.ToString());
exUser = _exUserService.GetById(exUser.Id);
exUser.AccessToken = oauthToken;
_exUserService.Update(exUser);
return(exUser.Id.ToString() + oauthToken);
}
public IActionResult InsertExternalUser([FromBody] ExternalUser externalUser)
{
try
{
var userModel = _userService.InsertExternalUser(externalUser);
return(Ok(new { Token = "sdsd" }));
}
catch (Exception ex)
{
}
finally
{
}
return(null);
}
internal static ExternalIdentityToken GetExternalIdentityToken(MailboxSession session, SmtpAddress externalId)
{
if (session != null && session.Capabilities.CanHaveExternalUsers)
{
using (ExternalUserCollection externalUsers = session.GetExternalUsers())
{
ExternalUser externalUser = externalUsers.FindExternalUser(externalId.ToString());
if (externalUser != null)
{
return(new ExternalIdentityToken(externalUser.Sid));
}
ExternalIdentityToken.Tracer.TraceError <SmtpAddress, IExchangePrincipal>(0L, "{0}: Unable to find the requester in the external user collection in mailbox {1}.", externalId, session.MailboxOwner);
}
}
return(null);
}
public async Task<Result<UserDTO>> GetExternalUserAsync(string provider, string nameIdendifier)
{
Result<UserDTO> res = new Result<UserDTO>();
ExternalUser extarnalUser = await _unitOfWork.EntityRepository<ExternalUser>().GetFirstAsync((ExternalUser w) => w.Provider == provider && w.NameIdentifier == nameIdendifier, null);
if (extarnalUser == null)
{
return res.Fail("ExternalUser yok!", null, "NOT_REGISTERED");
}
User user = await _unitOfWork.EntityRepository<User>().GetFirstAsync((User w) => (object)w.ExternalUserId == (object)(int?)extarnalUser.Id && !w.IsDeleted, null);
if (user == null)
{
return res.Fail("User yok!", null, "NOT_REGISTERED");
}
UserDTO dataVal = Mapper.Map<User, UserDTO>(user);
return res.Success(dataVal);
}
public async Task<Result<UserDTO>> AddExternalUserAsync(string provider, string nameIdendifier, UserDTO model)
{
Result<UserDTO> res = new Result<UserDTO>();
ExternalUser entity = new ExternalUser
{
NameIdentifier = nameIdendifier,
Provider = provider
};
ExternalUser externalUser = await _unitOfWork.EntityRepository<ExternalUser>().CreateAsync(entity);
if (externalUser == null)
{
return res.Fail("Kullanıcı oluşturulamadı!");
}
model.IsExternal = true;
model.ExternalUserId = externalUser.Id;
return await AddUserAsync(model);
}
public static ExternalUserEntity Map(ExternalUser dto)
{
return(new ExternalUserEntity()
{
IdTercero = dto.IdTercero,
NombreTercero = dto.NombreTercero,
TipoTercero = dto.TipoTercero,
Estado = dto.Estado,
FechaCreacionTercero = dto.FechaCreacionTercero,
TelefonoTercero1 = dto.TelefonoTercero1,
TelefonoTercero2 = dto.TelefonoTercero2,
TelefonoTercero3 = dto.TelefonoTercero3,
DireccionTercero1 = dto.DireccionTercero1,
DireccionTercero2 = dto.DireccionTercero2,
ObservacionTercero = dto.ObservacionTercero
});
}
public ExternalUser GetExternalUserByUserName(RequestBase req, string UserName)
{
ExternalUser result = null;
try
{
SqlSvrDAL dal = new SqlSvrDAL(req.ClientInfo);
result = dal.GetExternalUserByUserName(UserName);
}
catch (Exception ex)
{
//LogHelper.AddLog("ExternalUserController,GetExternalUserByUserName", ex.Message, ex.StackTrace, "HCL.Academy.Service", req.ClientInfo.emailId);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(result);
}
partial void DeleteExternalUser(ExternalUser instance);
public RegisterExistingViewModel(string username, string email, ExternalUser user)
{
UserName = username;
Email = email;
ExternalUser = user;
}
partial void InsertExternalUser(ExternalUser instance);
partial void UpdateExternalUser(ExternalUser instance);
