public static async Task <PreAuthDomain> GetMatchedDomain(string email)
{
var domain = email.Split('@')[1];
var res = await PreAuthDomain.GetDomainByName(domain);
return(res);
}
public async Task <ActionResult> Edit(PreAuthDomain domain)
{
ViewBag.Templates = GetTemplates(domain.InviteTemplateId);
ViewBag.Groups = GetGroups(domain.Groups);
if (ModelState.IsValid)
{
try
{
domain.AuthUser = User.Identity.GetEmail();
if (domain.Id == null)
{
domain = await PreAuthDomain.AddDomain(domain);
}
else
{
domain = await PreAuthDomain.UpdateDomain(domain);
}
return(RedirectToAction("Index"));
}
catch
{
ViewBag.Operation = "Edit";
return(View(domain));
}
}
return(View(domain));
}
public static async Task <string> GetRedirUrl(string upn)
{
var domainName = upn.Split('@')[1];
var domProfile = (await PreAuthDomain.GetDomains(d => d.DomainName == domainName)).SingleOrDefault();
var res = (domProfile == null) ? Settings.CurrSiteConfig.SiteRedemptionSettings.InviteRedirectUrl :
(!string.IsNullOrEmpty(domProfile.DomainRedemptionSettings.InviteRedirectUrl))
? domProfile.DomainRedemptionSettings.InviteRedirectUrl
: Settings.CurrSiteConfig.SiteRedemptionSettings.InviteRedirectUrl;
return(res);
}
public static async Task <PreAuthDomain> GetMatchedDomain(string email)
{
var d = email.Split('@');
PreAuthDomain res = null;
if (d.Length == 2)
{
var domain = d[1];
res = await PreAuthDomain.GetDomainByName(domain);
}
return(res);
}
public async Task <ActionResult> Delete(PreAuthDomain domain)
{
try
{
await PreAuthDomain.DeleteDomain(domain);
return(RedirectToAction("Index"));
}
catch
{
ViewBag.Operation = "Delete";
return(RedirectToAction("Index"));
}
}
public async Task <ActionResult> Index()
{
IEnumerable <PreAuthDomain> domains = null;
try
{
domains = await PreAuthDomain.GetDomains();
}
catch (Exception)
{
//see if this domain needs the group object updated
domains = await PreAuthDomain.RefreshAllPreAuthGroupData();
}
return(View(domains));
}
public async Task <ActionResult> Edit(string id)
{
PreAuthDomain domain;
if (id == null)
{
ViewBag.Operation = "Create";
domain = new PreAuthDomain();
domain.DomainRedemptionSettings.InviteRedirectUrl = string.Format("https://myapps.microsoft.com/{0}", Settings.Tenant);
domain.DomainRedemptionSettings.InviterResponseEmailAddr = User.Identity.GetClaim(ClaimTypes.Email);
}
else
{
ViewBag.Operation = "Edit";
domain = await PreAuthDomain.GetDomain(id);
}
ViewBag.Templates = GetTemplates(domain.InviteTemplateId);
return(View(domain));
}
public async Task <ActionResult> Create(PreAuthDomain domain)
{
ViewBag.Templates = GetTemplates(domain.InviteTemplateId);
if (ModelState.IsValid)
{
try
{
domain.AuthUser = User.Identity.GetEmail();
var doc = await PreAuthDomain.AddDomain(domain);
return(RedirectToAction("Index"));
}
catch
{
return(View("Edit", domain));
}
}
return(View("Edit", domain));
}
public static async Task <string> SendInvitation(GuestRequest request, string profileUrl, PreAuthDomain domainSettings = null)
{
var displayName = string.Format("{0} {1}", request.FirstName, request.LastName);
var useCustomEmailTemplate = false;
var redemptionSettings = Settings.SiteRedemptionSettings;
var memberType = MemberType.Guest;
//use domain custom setting if exists, else use global site config setting
if (domainSettings != null)
{
redemptionSettings = domainSettings.DomainRedemptionSettings;
//domainSettings.InviteTemplateContent;
memberType = domainSettings.MemberType;
if (!string.IsNullOrEmpty(domainSettings.InviteTemplateId))
{
useCustomEmailTemplate = true;
}
}
AdalResponse serverResponse = null;
try
{
// Setup invitation
var inviteEndPoint = string.Format("{0}/{1}/invitations", Settings.GraphResource, Settings.GraphApiVersion);
GraphInvitation invitation = new GraphInvitation();
invitation.InvitedUserDisplayName = displayName;
invitation.InvitedUserEmailAddress = request.EmailAddress;
invitation.InviteRedirectUrl = profileUrl;
invitation.SendInvitationMessage = (!Settings.UseSMTP);
invitation.InvitedUserType = memberType.ToString();
if (useCustomEmailTemplate && invitation.SendInvitationMessage && domainSettings.InviteTemplateContent.TemplateContent != null)
{
invitation.InvitedUserMessageInfo = new InvitedUserMessageInfo
{
CustomizedMessageBody = domainSettings.InviteTemplateContent.TemplateContent
};
}
// Invite user. Your app needs to have User.ReadWrite.All or Directory.ReadWrite.All to invite
serverResponse = CallGraph(inviteEndPoint, invitation);
var responseData = JsonConvert.DeserializeObject <GraphInvitation>(serverResponse.ResponseContent);
if (responseData.id == null)
{
return(string.Format("Error: Invite not sent - API error: {0}", serverResponse.Message));
}
if (domainSettings != null)
{
if (domainSettings.Groups != null && domainSettings.Groups.Count > 0)
{
var groupsAdded = AddUserToGroup(responseData.InvitedUser.Id, domainSettings.Groups);
//todo: log or notify re the negative
}
}
if (Settings.UseSMTP)
{
var emailSubject = Settings.InvitationEmailSubject.Replace("{{orgname}}", Settings.InvitingOrganization);
string body = FormatEmailBody(responseData, redemptionSettings, domainSettings.InviteTemplateContent);
SendViaSMTP(emailSubject, body, invitation.InvitedUserEmailAddress);
}
return(responseData.Status);
}
catch (Exception ex)
{
var reason = (serverResponse == null ? "N/A" : serverResponse.ResponseContent);
return(string.Format("Error: {0}<br>Server response: {1}", ex.Message, reason));
}
}
public async Task <GraphInvitation> ProcessInvitationAsync(GuestRequest request, PreAuthDomain domainSettings = null)
{
var displayName = string.Format("{0} {1}", request.FirstName, request.LastName);
var useCustomEmailTemplate = false;
var redemptionSettings = Settings.CurrSiteConfig.SiteRedemptionSettings;
var inviteTemplate = Settings.CurrSiteConfig.InviteTemplateContent;
var memberType = MemberType.Guest;
//use domain custom setting if exists, else use global site config setting
if (domainSettings != null)
{
redemptionSettings = domainSettings.DomainRedemptionSettings;
inviteTemplate = domainSettings.InviteTemplateContent;
memberType = domainSettings.MemberType;
if (!string.IsNullOrEmpty(domainSettings.InviteTemplateId))
{
useCustomEmailTemplate = true;
}
}
try
{
// Setup invitation
GraphInvitation invitation = new GraphInvitation()
{
InvitedUserDisplayName = displayName,
InvitedUserEmailAddress = request.EmailAddress,
InviteRedirectUrl = _profileUrl,
SendInvitationMessage = (!Settings.UseSMTP),
InvitedUserType = memberType.ToString()
};
if (useCustomEmailTemplate && invitation.SendInvitationMessage && domainSettings.InviteTemplateContent.TemplateContent != null)
{
invitation.InvitedUserMessageInfo = new InvitedUserMessageInfo
{
CustomizedMessageBody = domainSettings.InviteTemplateContent.TemplateContent
};
}
var groups = new List <GroupObject>();
if (domainSettings != null)
{
if (domainSettings.Groups != null && domainSettings.Groups.Count > 0)
{
groups = domainSettings.Groups;
}
}
return(await SendGraphInvitationAsync(invitation, groups, redemptionSettings.InviterResponseEmailAddr, inviteTemplate));
}
catch (Exception ex)
{
return(new GraphInvitation
{
ErrorInfo = string.Format("Error: {0}", ex.Message)
});
}
}
public async Task <ActionResult> Index()
{
IEnumerable <PreAuthDomain> domains = await PreAuthDomain.GetDomains();
return(View(domains));
}
public static async Task <GuestRequest> ExecuteDispositionAsync(GuestRequest request, string approver, string profileUrl, PreAuthDomain domainSettings = null)
{
request.AuthUser = approver;
request.LastModDate = DateTime.UtcNow;
if (request.Disposition == Disposition.Approved || request.Disposition == Disposition.AutoApproved)
{
//INVITE
request.Status = await InviteManager.SendInvitation(request, profileUrl, domainSettings);
if (request.Status.Substring(0, 5) == "Error")
{
request.Disposition = Disposition.Pending;
}
}
//UPDATE
await DocDBRepo.DB <GuestRequest> .UpdateItemAsync(request);
return(request);
}
public static async Task <GuestRequest> ExecuteDispositionAsync(GuestRequest request, string approver, string profileUrl, PreAuthDomain domainSettings = null)
{
request.AuthUser = approver;
request.LastModDate = DateTime.UtcNow;
if (request.Disposition == Disposition.Approved || request.Disposition == Disposition.AutoApproved)
{
//INVITE (request updated internally)
var mgr = new InviteManager(profileUrl, null);
request = await mgr.ProcessInvitationAsync(request, domainSettings);
}
else if (request.Disposition == Disposition.Denied)
{
//UPDATE GuestRequest to set denied status
request = await UpdateAsync(request);
}
return(request);
}
public static async Task <GuestRequest> ExecuteDispositionAsync(GuestRequest request, string approver, string profileUrl, PreAuthDomain domainSettings = null)
{
request.AuthUser = approver;
request.LastModDate = DateTime.UtcNow;
if (request.Disposition == Disposition.Approved || request.Disposition == Disposition.AutoApproved)
{
//INVITE
var mgr = new InviteManager(profileUrl, null);
var res = await mgr.ProcessInvitationAsync(request, domainSettings);
request.Status = res.Status;
if (request.Status.Substring(0, 5) == "Error")
{
request.Disposition = Disposition.Pending;
}
request.InvitationResult = res;
}
//UPDATE
await DocDBRepo.DB <GuestRequest> .UpdateItemAsync(request);
return(request);
}
