public async Task <ActionResult> Save(InviteTemplate template)
 {
     if (ModelState.IsValid)
     {
         //check for subject template if smtp
         if (Settings.UseSMTP)
         {
             if (string.IsNullOrEmpty(template.SubjectTemplate))
             {
                 ModelState.AddModelError("SubjectTemplate", "With SMTP enabled, the subject template is required.");
                 return(View("Edit", template));
             }
         }
         try
         {
             template.TemplateAuthor = User.Identity.GetEmail();
             if (template.Id == null)
             {
                 template = await TemplateUtilities.AddTemplate(template);
             }
             else
             {
                 template = await TemplateUtilities.UpdateTemplate(template);
             }
             return(RedirectToAction("Index"));
         }
         catch
         {
             return(View("Edit", template));
         }
     }
     return(View("Edit", template));
 }
Exemplo n.º 2
0
        public static async Task <IEnumerable <InviteTemplate> > InitializeDefaultTemplate(string templateAuthor)
        {
            var template = new InviteTemplate
            {
                LastUpdated     = DateTime.UtcNow,
                TemplateAuthor  = templateAuthor,
                TemplateName    = "Default",
                TemplateVersion = 1
            };

            template.SubjectTemplate = AdalUtil.Settings.InvitationEmailSubject;

            if (Settings.UseSMTP)
            {
                template.TemplateContent = Settings.GetMailTemplate(AdalUtil.Settings.DefaultBodyTemplateName);
            }
            else
            {
                template.TemplateContent = "";
            }

            template = (await DocDBRepo.DB <InviteTemplate> .CreateItemAsync(template));
            var res = new List <InviteTemplate>();

            res.Add(template);
            return(res);
        }
Exemplo n.º 3
0
        public static async Task <InviteTemplate> UpdateTemplate(InviteTemplate template)
        {
            template.LastUpdated = DateTime.UtcNow;
            template.TemplateVersion++;

            //TOSDocument is decorated with [AllowHtml], so clearing out dangerous tags
            template.TemplateContent = HtmlSanitizer.SanitizeHtml(template.TemplateContent);

            template = (await DocDBRepo.DB <InviteTemplate> .UpdateItemAsync(template));

            return(template);
        }
        public async Task <ActionResult> Delete(InviteTemplate template)
        {
            try
            {
                await TemplateUtilities.DeleteTemplate(template);

                return(RedirectToAction("Index"));
            }
            catch
            {
                ViewBag.Operation = "Delete";
                return(RedirectToAction("Index"));
            }
        }
        public async Task <ActionResult> Edit(string id)
        {
            InviteTemplate template;

            if (id == null)
            {
                ViewBag.Operation = "New";
                template          = new InviteTemplate();
            }
            else
            {
                ViewBag.Operation = "Edit";
                template          = await TemplateUtilities.GetTemplate(id);
            }
            return(View(template));
        }
Exemplo n.º 6
0
        public static async Task <IEnumerable <InviteTemplate> > InitializeDefaultTemplate(string templateAuthor)
        {
            var template = new InviteTemplate
            {
                LastUpdated     = DateTime.UtcNow,
                TemplateAuthor  = templateAuthor,
                TemplateName    = "Default",
                TemplateVersion = 1
            };

            template.SubjectTemplate = MailSender.GetTemplateContents(Settings.DefaultSubjectTemplateName);
            template.TemplateContent = MailSender.GetTemplateContents(Settings.DefaultBodyTemplateName);

            template = (await DocDBRepo.DB <InviteTemplate> .CreateItemAsync(template));
            var res = new List <InviteTemplate>
            {
                template
            };

            return(res);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Load latest site configuration record from the database.
        /// </summary>
        /// <returns>false if no record found, true indicates the latest record is available in Settings.CurrSiteConfig</returns>
        public static async Task <bool> LoadCurrSiteConfig()
        {
            try
            {
                Settings.CurrSiteConfig = await GetCurrConfig();

                if (Settings.CurrSiteConfig != null)
                {
                    if (Settings.CurrSiteConfig.InviteTemplateId != null)
                    {
                        Settings.CurrSiteConfig.InviteTemplateContent = await InviteTemplate.GetTemplate(Settings.CurrSiteConfig.InviteTemplateId);
                    }
                }

                Settings.SiteConfigReady = (Settings.CurrSiteConfig != null);
                return(Settings.SiteConfigReady);
            }
            catch (Exception ex)
            {
                Logging.WriteToAppLog("Problem loading site config", System.Diagnostics.EventLogEntryType.Error, ex);
                Settings.SiteConfigReady = false;
                return(Settings.SiteConfigReady);
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// Load latest site configuration record from the database.
        /// </summary>
        /// <returns>false if no record found, true indicates the latest record is available in Settings.CurrSiteConfig</returns>
        public static bool LoadCurrSiteConfig()
        {
            try
            {
                CurrSiteConfig = DocDBRepo.DB <SiteConfig> .GetItemsAsync(c => c.DocType == DocTypes.SiteConfig).Result.LastOrDefault();

                if (CurrSiteConfig != null)
                {
                    if (CurrSiteConfig.InviteTemplateId != null)
                    {
                        CurrSiteConfig.InviteTemplateContent = InviteTemplate.GetTemplate(CurrSiteConfig.InviteTemplateId).GetAwaiter().GetResult();
                    }
                }

                SiteConfigReady = (CurrSiteConfig != null);
                return(SiteConfigReady);
            }
            catch (Exception ex)
            {
                Logging.WriteToAppLog("Problem loading site config", System.Diagnostics.EventLogEntryType.Error, ex);
                SiteConfigReady = false;
                return(SiteConfigReady);
            }
        }
Exemplo n.º 9
0
 public PreAuthDomain()
 {
     DomainRedemptionSettings = new RedemptionSettings();
     InviteTemplateContent    = new InviteTemplate();
     Groups = new List <GroupObject>();
 }
Exemplo n.º 10
0
 public SiteConfig()
 {
     SiteRedemptionSettings = new RedemptionSettings();
     SiteRedemptionSettings.InviteRedirectUrl = string.Format("https://myapps.microsoft.com/{0}", Settings.Tenant);
     InviteTemplateContent = new InviteTemplate();
 }
Exemplo n.º 11
0
        private static string FormatEmailBody(GraphInvitation data, RedemptionSettings redemption, InviteTemplate content)
        {
            var body = content.TemplateContent;

            body = body.Replace("{{InvitingOrgName}}", Settings.InvitingOrganization);
            body = body.Replace("{{InvitationLink}}", data.InviteRedeemUrl);
            body = body.Replace("{{OrgContactEmail}}", redemption.InviterResponseEmailAddr);
            return(body);
        }
Exemplo n.º 12
0
        private static string FormatEmailBody(GraphInvitation invitation, string inviterResponseEmailAddr, InviteTemplate mailTemplate)
        {
            var body = mailTemplate.TemplateContent;

            body = body.Replace("{{InvitingOrgName}}", Settings.CurrSiteConfig.InvitingOrg);
            body = body.Replace("{{InvitationLink}}", invitation.InviteRedeemUrl);
            body = body.Replace("{{InvitationStatus}}", invitation.Status);
            if (invitation.InvitedUserMessageInfo != null)
            {
                body = body.Replace("{{CustomMessage}}", invitation.InvitedUserMessageInfo.CustomizedMessageBody);
            }
            body = body.Replace("{{OrgContactEmail}}", inviterResponseEmailAddr);
            return(body);
        }
Exemplo n.º 13
0
        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);
            }
        }
Exemplo n.º 14
0
 public static async Task <dynamic> DeleteTemplate(InviteTemplate template)
 {
     return(await DocDBRepo.DB <InviteTemplate> .DeleteItemAsync(template));
 }
Exemplo n.º 15
0
 public static async Task <InviteTemplate> AddTemplate(InviteTemplate template)
 {
     template.LastUpdated = DateTime.UtcNow;
     return(await DocDBRepo.DB <InviteTemplate> .CreateItemAsync(template));
 }
Exemplo n.º 16
0
        /// <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);
            }
        }