public async Task <bool> CheckDomain(PreAuthReq req)
{
var domainName = req.Email.Split('@')[1];
var domain = await GuestRequestRules.GetPreauthDomain(domainName);
return(domain != null);
}
public async Task <ActionResult> SignUp(GuestRequest request)
{
//sanity check: not trusting the passed-in preauth setting
request.PreAuthed = (User.Identity.GetClaim(CustomClaimTypes.AuthType) == AuthTypes.B2EMulti);
var result = await GuestRequestRules.SignUpAsync(request, Utils.GetProfileUrl(Request));
return(View(result));
}
private async Task <GraphInvitation> SendGraphInvitationAsync(GraphInvitation invitation, List <GroupObject> groups, string inviterResponseEmailAddr = null, InviteTemplate mailTemplate = null, string accessToken = null)
{
AdalResponse serverResponse = null;
GraphInvitation responseData = new GraphInvitation();
try
{
var inviteEndPoint = string.Format("{0}/{1}/invitations", Settings.GraphResource, Settings.GraphApiVersion);
// Invite user. Your app needs to have User.ReadWrite.All or Directory.ReadWrite.All to invite
serverResponse = AdalUtil.CallGraph(inviteEndPoint, invitation, false, null, _user, accessToken);
responseData = JsonConvert.DeserializeObject <GraphInvitation>(serverResponse.ResponseContent);
if (responseData.id == null)
{
responseData.ErrorInfo = string.Format("Error: Invite not sent - API error: {0}", serverResponse.Message);
return(responseData);
}
if (groups.Count > 0)
{
var groupsAdded = AddUserToGroup(responseData.InvitedUser.Id, groups);
if (!groupsAdded.Success)
{
var resErrors = string.Join(", ", groupsAdded.Responses.Where(r => !r.Successful).Select(r => r.Message));
responseData.ErrorInfo += string.Format("\n\rOne or more groups failed while assigning to user \"{0}\" ({1})", responseData.InvitedUserEmailAddress, resErrors);
}
}
if (Settings.UseSMTP)
{
mailTemplate = mailTemplate ?? Settings.CurrSiteConfig.InviteTemplateContent;
var emailSubject = mailTemplate.SubjectTemplate.Replace("{{InvitingOrgName}}", Settings.CurrSiteConfig.InvitingOrg);
string body = FormatEmailBody(responseData, inviterResponseEmailAddr, mailTemplate);
SendViaSMTP(emailSubject, body, invitation.InvitedUserEmailAddress);
}
var request = await GuestRequestRules.GetUserAsync(invitation.InvitedUserEmailAddress);
request.InvitationResult = responseData;
await GuestRequestRules.UpdateAsync(request);
return(responseData);
}
catch (Exception ex)
{
var reason = (serverResponse == null ? "N/A" : serverResponse.ResponseContent);
responseData.ErrorInfo = string.Format("Error: {0}<br>Server response: {1}", ex.Message, reason);
return(responseData);
}
}
public async Task <ActionResult> SignUp(GuestRequest request)
{
var r = new RegexUtilities();
if (!r.IsValidEmail(request.EmailAddress))
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
//sanity check: not trusting the passed-in preauth setting
request.PreAuthed = (User.Identity.GetClaim(CustomClaimTypes.AuthType) == AuthTypes.B2EMulti);
var result = await GuestRequestRules.SignUpAsync(request, Utils.GetProfileUrl(Request.Url));
return(View(result));
}
public async Task <ActionResult> Approve()
{
var approveCount = 0;
var deniedCount = 0;
var sentCount = 0;
var requestList = await GuestRequestRules.GetPendingRequestsAsync();
foreach (var request in requestList)
{
var strDisposition = Request.Form[string.Format("Disposition.{0}", request.Id)];
var disposition = (Disposition)Enum.Parse(typeof(Disposition), strDisposition);
switch (disposition)
{
case Disposition.Pending:
break;
case Disposition.Approved:
approveCount++;
break;
case Disposition.Denied:
deniedCount++;
break;
}
request.Disposition = disposition;
request.InternalComment = Request.Form[string.Format("InternalComment.{0}", request.Id)];
var domain = await GuestRequestRules.GetMatchedDomain(request.EmailAddress);
var res = await GuestRequestRules.ExecuteDispositionAsync(request, User.Identity.Name, Utils.GetProfileUrl(Request.Url), domain);
if (res != null && (res.InvitationResult.SendInvitationMessage || res.MailSent))
{
sentCount++;
}
}
requestList = await GuestRequestRules.GetPendingRequestsAsync();
ViewBag.Message = string.Format("{0} {1} approved, {2} {3} denied, {4} {5} invitations sent.", approveCount, Utils.Pluralize(approveCount, "request"), deniedCount, Utils.Pluralize(deniedCount, "request"), sentCount, Utils.Pluralize(sentCount, "invitation"));
return(View("Index", requestList));
}
//private BulkInviteResults SubmitToGraphBatch(GraphBatch batch, BulkInviteSubmission submission)
//{
// //** NOTE: this method was last tested against the beta API, circa Q3 CY17 **
// var res = new BulkInviteResults();
// var batchEndPoint = string.Format("{0}/beta/$batch", Settings.GraphResource);
// var serverResponse = CallGraph(batchEndPoint, batch, false, null, _userId);
// if (serverResponse.Successful)
// {
// res.InvitationResults = JsonConvert.DeserializeObject<GraphBatchResponse>(serverResponse.ResponseContent);
// if (submission.GroupList.Length > 0)
// {
// foreach (var item in res.InvitationResults.Responses)
// {
// var groupsAdded = AddUserToGroup(item.Body.InvitedUser.Id, submission.GroupList.ToList());
// if (!groupsAdded.Success)
// {
// var resErrors = string.Join(", ", groupsAdded.Responses.Where(r => !r.Successful).Select(r => r.Message));
// res.ErrorMessage += string.Format("\n\rOne or more groups failed while assigning to user \"{0}\" ({1})", item.Body.InvitedUserEmailAddress, resErrors);
// }
// }
// }
// }
// else
// {
// res.ErrorMessage = serverResponse.Message;
// }
// return res;
//}
private async Task <BulkInviteResults> SubmitLocally(GraphBatch batch, BulkInviteSubmission submission)
{
var res = new BulkInviteResults(submission.Id);
GraphInvitation itemRes;
var mailTemplate = await TemplateUtilities.GetTemplate(submission.InviteTemplateId);
try
{
foreach (var item in batch.Requests)
{
itemRes = await SendGraphInvitationAsync(item.Body, submission.GroupList.ToList(), null, mailTemplate, _accessToken);
if (itemRes.Status != "Error")
{
submission.ItemsProcessed += 1;
submission = await BulkInviteSubmission.UpdateItem(submission);
}
item.Request.Status = itemRes.Status;
await GuestRequestRules.UpdateAsync(item.Request);
res.InvitationResults.Responses.Add(new BulkResponse
{
Status = itemRes.Status,
Body = itemRes,
Id = itemRes.id
});
}
await BulkInviteResults.AddItem(res);
return(res);
}
catch (Exception ex)
{
res.ErrorMessage = ex.Message;
await BulkInviteResults.AddItem(res);
return(res);
}
}
public static async Task <bool> DeleteBatch(string submissionId)
{
var submission = await GetItem(submissionId);
var requests = await GuestRequestRules.GetBatchRequest(submissionId);
foreach (var request in requests)
{
await GuestRequestRules.DeleteAsync(request);
}
var results = await BulkInviteResults.GetItems(submissionId);
foreach (var result in results)
{
await BulkInviteResults.DeleteItem(result);
}
await DeleteItem(submission);
return(true);
}
public async Task <IEnumerable <BulkInviteResults> > GetBatchProcessingHistory(string id)
{
IEnumerable <BulkInviteResults> history = (await GuestRequestRules.GetBatchSubmissionHistory(id));
return(history);
}
public async Task <IEnumerable <GuestRequest> > GetHistory([FromUri] HistoryFilter filter)
{
IEnumerable <GuestRequest> history = (await GuestRequestRules.GetHistory(filter)).OrderByDescending(h => h.RequestDate);
return(history);
}
/// <summary>
/// GraphInvitation is a model from https://developer.microsoft.com/en-us/graph/docs/api-reference/v1.0/resources/invitation
/// Do not alter
/// </summary>
/// <param name="invitation">The GraphInvitation object transmitted to the B2B Guest API</param>
/// <param name="groups">Azure AD groups to assign the guest user to</param>
/// <param name="inviterResponseEmailAddr"></param>
/// <param name="mailTemplate"></param>
/// <param name="accessToken"></param>
/// <returns></returns>
private async Task <GuestRequest> SendGraphInvitationAsync(GraphInvitation invitation, List <GroupObject> groups, GuestRequest request, string inviterResponseEmailAddr = null, InviteTemplate mailTemplate = null, string accessToken = null)
{
AdalResponse serverResponse = null;
GraphInvitation responseData = new GraphInvitation();
try
{
var inviteEndPoint = string.Format("{0}/{1}/invitations", Settings.GraphResource, Settings.GraphApiVersion);
// Invite user. Your app needs to have User.ReadWrite.All or Directory.ReadWrite.All to invite
serverResponse = AdalUtil.CallGraph(inviteEndPoint, invitation, false, null, _user, accessToken);
responseData = JsonConvert.DeserializeObject <GraphInvitation>(serverResponse.ResponseContent);
request.InvitationResult = responseData;
request.Status = responseData.Status;
if (responseData.id == null)
{
//API call failed - put the request back in the queue
responseData.ErrorInfo = string.Format("Error: Invite not sent - API error: {0}", serverResponse.Message);
request.InvitationResult = responseData;
request.Disposition = Disposition.Pending;
}
else
{
//invitation API call successful
if (responseData.Status.Substring(0, 5) == "Error")
{
//API call was successful but something failed while trying to process the request - put the request back in the queue
request.Disposition = Disposition.Pending;
}
else
{
//check to see if groups should be assigned
if (groups.Count > 0)
{
try
{
var groupsAdded = AddUserToGroup(responseData.InvitedUser.Id, groups);
if (!groupsAdded.Success)
{
//group assignment failed
var resErrors = string.Join(", ", groupsAdded.Responses.Where(r => !r.Successful).Select(r => r.Message));
var msg = string.Format("\n\rOne or more groups failed while assigning to user \"{0}\" ({1})", responseData.InvitedUserEmailAddress, resErrors);
request.PostProcessingStatus += msg;
}
}
catch (Exception groupEx)
{
//group assignment errored
var msg = string.Format("\n\rAn error occured while assigning a group to user \"{0}\" ({1})", responseData.InvitedUserEmailAddress, groupEx.Message);
Logging.WriteToAppLog(msg, EventLogEntryType.Warning, groupEx);
request.PostProcessingStatus += msg;
}
}
//check to see if custom mail should be sent
if (Settings.UseSMTP)
{
try
{
mailTemplate = mailTemplate ?? Settings.CurrSiteConfig.InviteTemplateContent;
var emailSubject = mailTemplate.SubjectTemplate.Replace("{{InvitingOrgName}}", Settings.CurrSiteConfig.InvitingOrg);
string body = FormatEmailBody(responseData, inviterResponseEmailAddr, mailTemplate);
SendViaSMTP(emailSubject, body, invitation.InvitedUserEmailAddress);
request.MailSent = true;
}
catch (Exception mailEx)
{
var msg = string.Format("\n\rSending invitation failed for user \"{0}\" ({1})", responseData.InvitedUserEmailAddress, mailEx.Message);
Logging.WriteToAppLog(msg, EventLogEntryType.Warning, mailEx);
request.PostProcessingStatus += msg;
}
}
}
}
//all attempts complete, UPDATE GuestRequest
await GuestRequestRules.UpdateAsync(request);
return(request);
}
catch (Exception ex)
{
var reason = (serverResponse == null ? "N/A" : serverResponse.ResponseContent);
responseData.ErrorInfo = string.Format("Error: {0}<br>Server response: {1}", ex.Message, reason);
request.InvitationResult = responseData;
//UPDATE GuestRequest
await GuestRequestRules.UpdateAsync(request);
return(request);
}
}
