/// <summary> /// Prepares to handle the form submission. /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public override void PrepareHandleForm(FormSubmissionContext context, object configuration) { // Track usage of this feature. UsageTracker.TrackDesignedEmail(); // Boilerplate. base.PrepareHandleForm(context, configuration); }
/// <summary> /// Handles a form submission (sends data to a web API). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Variables. var config = configuration as SendDataConfiguration; var form = context.Form; var data = context.Data; var result = default(SendDataResult); // Convert lists into dictionary. var fieldsById = form.Fields.ToDictionary(x => x.Id, x => x); var valuesById = data.GroupBy(x => x.FieldId).Select(x => new { Id = x.Key, Values = x.SelectMany(y => y.FieldValues).ToList() }).ToDictionary(x => x.Id, x => x.Values); // Attempts to get a field value. Func <Guid, string> tryGetValue = fieldId => { var tempValues = default(List <string>); var tempField = default(IFormField); var hasValues = valuesById.TryGetValue(fieldId, out tempValues); var hasField = fieldsById.TryGetValue(fieldId, out tempField); if (hasField && (hasValues || tempField.IsServerSideOnly)) { tempValues = hasValues ? tempValues : null; return(tempField.FormatValue(tempValues, FieldPresentationFormats.Transmission)); } return(null); }; // Get the data to transmit. var transmissionData = config.Fields .Where(x => fieldsById.ContainsKey(x.FieldId)) .Select(x => new KeyValuePair <string, string>(x.FieldName, tryGetValue(x.FieldId))) .Where(x => x.Value != null) .ToArray(); // Query string format? if ("Query String".InvariantEquals(config.TransmissionFormat)) { result = SendQueryStringRequest(config.Url, transmissionData, config.Method); } // Call function to handle result? if (context != null) { result.Context = context; } config?.ResultHandler?.HandleResult(result); }
/// <summary> /// Handles a form submission (stores it). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Store the submission to the database. if (Submission != null) { var db = context.UmbracoContext.Application.DatabaseContext.Database; db.Insert(Submission); } }
/// <summary> /// Handles a form submission (sends an email). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Variables. var form = context.Form; var data = context.Data; var files = context.Files; var payload = context.Payload; // Create message. var config = configuration as EmailConfiguration; var message = new MailMessage() { IsBodyHtml = false }; message.From = new MailAddress(config.SenderEmail); message.Subject = config.Subject; // Any allowed recipients (if not, abort early)? var allowedRecipients = FilterEmails(config.Recipients); if (!allowedRecipients.Any()) { return; } foreach (var recipient in allowedRecipients) { message.To.Add(recipient); } // Append fields? if (config.AppendFields) { var chosenPayload = config.AppendPayload ? payload : payload.Take(0); message.Body = ConstructMessage(form, data, files, chosenPayload, config); foreach (var file in files) { var dataStream = new MemoryStream(file.FileData); message.Attachments.Add(new Attachment(dataStream, file.FileName)); } } else { message.Body = config.Message; } // Send email. using (var client = new SmtpClient()) { client.Send(message); } }
/// <summary> /// Handles a form submission (sends an email). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Send email. if (Message != null) { using (var client = new SmtpClient()) { client.Send(Message); } } }
/// <summary> /// Returns a dictionary of form field values by field alias. /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <returns> /// The dictionary of form field values. /// </returns> private Dictionary <string, object[]> GetFormValues(FormSubmissionContext context) { // Variables. var data = context.Data; var files = context.Files; var payload = context.Payload; var fieldsById = context.Form.Fields.ToDictionary(x => x.Id, x => x); var values = new Dictionary <string, object[]>(); // Add the payload items. foreach (var item in payload) { values[item.Name] = new[] { item.Value }; } // Add the field values. foreach (var item in data) { var field = fieldsById[item.FieldId]; var name = string.IsNullOrWhiteSpace(field.Alias) ? field.Name : field.Alias; if (string.IsNullOrWhiteSpace(name)) { continue; } values[name] = item.FieldValues.MakeSafe().ToArray(); } // Add the files. foreach (var item in files) { var field = fieldsById[item.FieldId]; var name = string.IsNullOrWhiteSpace(field.Alias) ? field.Name : field.Alias; if (string.IsNullOrWhiteSpace(name)) { continue; } values[name] = new[] { item }; } // Return the dictionary of values. return(values); }
/// <summary> /// Handles a form submission (sends an email). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Variables. var config = configuration as EmailConfiguration; var form = context.Form; var data = context.Data; var dataForMessage = data; var files = context.Files; var filesForMessage = files; var payload = context.Payload; var extraContext = context.ExtraContext; var extraEmails = (AttemptGetValue(extraContext, ExtraRecipientsKey) as List <string>).MakeSafe(); var extraSubject = AttemptGetValue(extraContext, ExtraSubjectKey) as string ?? string.Empty; var extraMessage = AttemptGetValue(extraContext, ExtraMessageKey) as string ?? string.Empty; var baseMessage = config.Message + extraMessage; // Create message. var message = new MailMessage() { IsBodyHtml = false }; message.From = new MailAddress(config.SenderEmail); message.Subject = config.Subject + extraSubject; // Get recipients from field values. var emailFieldIds = new HashSet <Guid>(config.RecipientFields); var fieldEmails = data .Where(x => emailFieldIds.Contains(x.FieldId)).SelectMany(x => x.FieldValues) .Where(x => !string.IsNullOrWhiteSpace(x)) .Where(x => IsEmailInValidFormat(x)); // Include only specific fields in the email message? if (config.FieldsToInclude.Any()) { // Variables. var fieldIdsToInclude = new HashSet <Guid>(config.FieldsToInclude); // Selected server side fields. var serverSideFields = form.Fields .Where(x => x.IsServerSideOnly) .Where(x => fieldIdsToInclude.Contains(x.Id)) .Select(x => new FieldSubmission() { FieldId = x.Id, // The values don't matter here, as the IFormFieldType.FormatValue is how server // side fields return a field value. FieldValues = Enumerable.Empty <string>() }); // Combine submitted data and server side field data. var dataWithServerSideFields = data.Concat(serverSideFields); // Filter normal fields. dataForMessage = dataWithServerSideFields .Where(x => fieldIdsToInclude.Contains(x.FieldId)).ToArray(); // Filter file fields. filesForMessage = files .Where(x => fieldIdsToInclude.Contains(x.FieldId)).ToArray(); } // Any allowed recipients (if not, abort early)? var rawRecipients = config.Recipients .Concat(fieldEmails) .Concat(extraEmails); var allowedRecipients = FilterEmails(rawRecipients); if (!allowedRecipients.Any()) { return; } foreach (var recipient in allowedRecipients) { // We don't want recipients to see each other, so we use BCC instead of TO. message.Bcc.Add(recipient); } // Append fields? if (config.AppendFields) { var chosenPayload = config.AppendPayload ? payload : payload.Take(0); message.Body = ConstructMessage(form, dataForMessage, filesForMessage, chosenPayload, baseMessage, config.IncludeHiddenFields, config.ExcludeFieldLabels); foreach (var file in filesForMessage) { var dataStream = new MemoryStream(file.FileData); message.Attachments.Add(new Attachment(dataStream, file.FileName)); } } else { message.Body = baseMessage; } // Send email. using (var client = new SmtpClient()) { client.Send(message); } }
/// <summary> /// Submits a form. /// </summary> /// <param name="formId"> /// The ID of the form to submit. /// </param> /// <param name="data"> /// The form data to submit. /// </param> /// <param name="files"> /// The file data to submit. /// </param> /// <param name="payload"> /// Extra data related to the submission. /// </param> /// <param name="options"> /// The options for this submission. /// </param> /// <param name="context"> /// The contextual information for the form request. /// </param> /// <returns> /// The result of the submission. /// </returns> public SubmissionResult SubmitForm(Guid formId, IEnumerable <FieldSubmission> data, IEnumerable <FileFieldSubmission> files, IEnumerable <PayloadSubmission> payload, SubmissionOptions options, FormRequestContext context) { // Is the form ID valid? var form = Forms.Retrieve(formId); if (form == null) { return(new SubmissionResult() { Success = false }); } // Create submission context. var submissionContext = new FormSubmissionContext() { Files = files, Data = data, Form = form, Payload = payload, CurrentPage = context.CurrentPage, HttpContext = context.HttpContext, Services = context.Services, UmbracoContext = context.UmbracoContext, UmbracoHelper = context.UmbracoHelper, SubmissionId = Guid.NewGuid(), ExtraContext = new Dictionary <string, object>(), SubmissionCancelled = false }; // Invoke submitting event (gives listeners a chance to change the submission). Submitting?.Invoke(submissionContext); // Fail the form submission if SubmissionCancelled is true. if (submissionContext.SubmissionCancelled) { return(new SubmissionResult() { Success = false }); } // Validate against native field validations. foreach (var field in form.Fields) { var fieldId = field.Id; var value = data.Where(x => x.FieldId == fieldId) .SelectMany(x => x.FieldValues); if (!field.IsValid(value)) { return(new SubmissionResult() { Success = false }); } } // Validate? if (options.Validate) { var valuesById = data.GroupBy(x => x.FieldId).Select(x => new { Id = x.Key, Values = x.SelectMany(y => y.FieldValues).ToList() }).ToDictionary(x => x.Id, x => x.Values); var filesById = files.GroupBy(x => x.FieldId).Select(x => new { Id = x.Key, Values = x.Select(y => y).ToList() }).ToDictionary(x => x.Id, x => x.Values); foreach (var field in form.Fields) { var validations = field.Validations .Select(x => Validations.Retrieve(x)) .ToList(); if (!validations.Any()) { continue; } var validationContext = new ValidationContext() { Field = field, Form = form }; foreach (var validation in validations) { var dataValues = valuesById.ContainsKey(field.Id) ? valuesById[field.Id] : new List <string>(); var fileValues = filesById.ContainsKey(field.Id) ? filesById[field.Id] : new List <FileFieldSubmission>(); var isValid = validation .IsValueValid(dataValues, fileValues, validationContext); if (!isValid) { return(new SubmissionResult() { Success = false }); } } } } // Prepare the form handlers. // This occurs on the current thread in case the handler needs information // only available in the current thread. var enabledHandlers = form.Handlers .Where(x => x.Enabled) .ToArray(); try { foreach (var handler in enabledHandlers) { handler.PrepareHandleForm(submissionContext); } } catch (Exception ex) { Logger.Error <Submissions_Instance>(ex, PreHandlerError); return(new SubmissionResult() { Success = false }); } // Initiate form handlers on a new thread (they may take some time to complete). var task = new Task(() => { foreach (var handler in enabledHandlers) { handler.HandleForm(submissionContext); } }); task.ContinueWith(FormHandlersExceptionHandler, TaskContinuationOptions.OnlyOnFaulted); task.Start(); // Return success. return(new SubmissionResult() { Success = true }); }
/// <summary> /// Prepares an mail message (e.g., sets the sender and recipients). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="config"> /// The configuration for preparing the email message. /// </param> /// <returns> /// The prepared mail message. /// </returns> protected MailMessage PrepareEmailMessage( FormSubmissionContext context, IEmailSenderRecipientConfiguration config) { // Variables. var data = context.Data; var extraContext = context.ExtraContext; var extraEmails = (AttemptGetValue(extraContext, ExtraRecipientsKey) as List <string>).MakeSafe(); // Create message. var message = new MailMessage { From = new MailAddress(config.SenderEmail) }; // Add headers to message. foreach (var header in Config.EmailHeaders) { message.Headers.Add(header.Name, header.Value); } // Get recipients from field values. var emailFieldIds = new HashSet <Guid>(config.RecipientFields); var fieldEmails = data .Where(x => emailFieldIds.Contains(x.FieldId)).SelectMany(x => x.FieldValues) .Where(x => !string.IsNullOrWhiteSpace(x)) .Where(x => IsEmailInValidFormat(x)) .ToArray(); // Any allowed recipients (if not, abort early)? var rawRecipients = config.Recipients .Concat(fieldEmails) .Concat(extraEmails); var allowedRecipients = FilterEmails(rawRecipients); if (!allowedRecipients.Any()) { return(null); } foreach (var recipient in allowedRecipients) { if ("to".InvariantEquals(config.DeliveryType as string)) { message.To.Add(recipient); } else if ("cc".InvariantEquals(config.DeliveryType as string)) { message.CC.Add(recipient); } else { message.Bcc.Add(recipient); } } // Return the mail message. return(message); }
/// <summary> /// Handles a form submission (sends an email). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public virtual void HandleForm(FormSubmissionContext context, object configuration) { // Prepare the message. var message = PrepareEmailMessage(context, configuration as IEmailSenderRecipientConfiguration); if (message == null) { return; } // Variables. var config = configuration as EmailConfiguration; var form = context.Form; var data = context.Data; var dataForMessage = data; var files = context.Files; var filesForMessage = files; var payload = context.Payload; var extraContext = context.ExtraContext; var extraSubject = AttemptGetValue(extraContext, ExtraSubjectKey) as string ?? string.Empty; var extraMessage = AttemptGetValue(extraContext, ExtraMessageKey) as string ?? string.Empty; var baseMessage = config.Message + extraMessage; var plainTextBody = default(string); var htmlBody = default(string); // Set the email subject. message.Subject = config.Subject + extraSubject; // Include only specific fields in the email message? if (config.FieldsToInclude.Any()) { // Variables. var fieldIdsToInclude = new HashSet <Guid>(config.FieldsToInclude); // Selected server side fields. var serverSideFields = form.Fields .Where(x => x.IsServerSideOnly) .Where(x => fieldIdsToInclude.Contains(x.Id)) .Select(x => new FieldSubmission() { FieldId = x.Id, // The values don't matter here, as the IFormFieldType.FormatValue is how server // side fields return a field value. FieldValues = Enumerable.Empty <string>() }); // Combine submitted data and server side field data. var dataWithServerSideFields = data.Concat(serverSideFields); // Filter normal fields. dataForMessage = dataWithServerSideFields .Where(x => fieldIdsToInclude.Contains(x.FieldId)).ToArray(); // Filter file fields. filesForMessage = files .Where(x => fieldIdsToInclude.Contains(x.FieldId)).ToArray(); } // Append fields? if (config.AppendFields) { var chosenPayload = config.AppendPayload ? payload : payload.Take(0); htmlBody = ConstructMessage(form, dataForMessage, filesForMessage, chosenPayload, baseMessage, config.IncludeHiddenFields, config.ExcludeFieldLabels, true); plainTextBody = ConstructMessage(form, dataForMessage, filesForMessage, chosenPayload, baseMessage, config.IncludeHiddenFields, config.ExcludeFieldLabels, false); foreach (var file in filesForMessage) { var dataStream = new MemoryStream(file.FileData); message.Attachments.Add(new Attachment(dataStream, file.FileName)); } } else { htmlBody = WebUtility.HtmlEncode(baseMessage); plainTextBody = baseMessage; } // Add plain text alternate view. var mimeType = new ContentType(MediaTypeNames.Text.Plain); var emailView = AlternateView.CreateAlternateViewFromString(plainTextBody, mimeType); message.AlternateViews.Add(emailView); // Add HTML alternate view. mimeType = new ContentType(MediaTypeNames.Text.Html); emailView = AlternateView.CreateAlternateViewFromString(htmlBody, mimeType); message.AlternateViews.Add(emailView); // Send email. using (var client = new SmtpClient()) { client.Send(message); } }
/// <summary> /// Prepares to handle to form submission. /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> /// <remarks> /// In this case, no preparation is necessary. /// </remarks> public void PrepareHandleForm(FormSubmissionContext context, object configuration) { }
/// <summary> /// Prepares to handle to form submission. /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> /// <remarks> /// In this case, no preparation is necessary. /// </remarks> public void PrepareHandleForm(FormSubmissionContext context, object configuration) { //TODO: Should probably prepare the data to be sent here (to avoid threading issues), but then send it in HandleForm. }
/// <summary> /// Handles a form submission (stores it). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Variables. var form = context.Form; var data = context.Data; var files = context.Files; var payload = context.Payload; var fieldsById = form.Fields.ToDictionary(x => x.Id, x => x); var db = context.UmbracoContext.Application.DatabaseContext.Database; // This will store the formatted values. var valueList = new[] { new { FieldId = default(string), // Field name is stored in case the field is deleted from the form // and this stored name is all we have to go on. FieldName = default(string), Value = default(string) } }.Take(0).ToList(); // Group the data values by their field ID. var valuesById = data.GroupBy(x => x.FieldId).Select(x => new { Id = x.Key, Values = x.SelectMany(y => y.FieldValues).ToList() }).ToDictionary(x => x.Id, x => x.Values); // Store the file values by their field ID. var filesById = files.GroupBy(x => x.FieldId).Select(x => new { Id = x.Key, Filename = x.Select(y => y.FileName).FirstOrDefault(), PathSegment = GenerateFilePathSegment(), FileData = x.Select(y => y.FileData).FirstOrDefault() }).ToDictionary(x => x.Id, x => x); // Normal fields. foreach (var key in valuesById.Keys) { var values = valuesById[key]; var formatted = string.Join(", ", values); var field = default(IFormField); var fieldName = default(string); if (fieldsById.TryGetValue(key, out field)) { formatted = field.FormatValue(values, FieldPresentationFormats.Storage); fieldName = field.Name; } valueList.Add(new { FieldId = GuidHelper.GetString(key), FieldName = fieldName, Value = formatted }); } // Store file information for serialization. var fileList = filesById.Values.Select(x => new { FieldId = x.Id, // Field name is stored in case the field is deleted from the form // and this stored name is all we have to go on. FieldName = GetFieldName(x.Id, fieldsById), PathSegment = x.PathSegment, Filename = x.Filename }); // Store the files. if (files.Any()) { // Ensure base path exists. var basePath = HostingEnvironment.MapPath(Config.FileStoreBasePath); if (!Directory.Exists(basePath)) { Directory.CreateDirectory(basePath); } // Create files. foreach(var key in filesById.Keys) { var file = filesById[key]; var fullPath = Path.Combine(basePath, file.PathSegment); var pathOnly = Path.GetDirectoryName(fullPath); Directory.CreateDirectory(pathOnly); File.WriteAllBytes(fullPath, file.FileData); } } // Store data to database. var serializedValues = JsonHelper.Serialize(valueList.ToArray()); var serializedFiles = JsonHelper.Serialize(fileList.ToArray()); db.Insert(new FormulateSubmission() { CreationDate = DateTime.UtcNow, DataValues = serializedValues, FileValues = serializedFiles, FormId = form.Id, GeneratedId = context.SubmissionId, PageId = context?.CurrentPage?.Id, Url = context?.CurrentPage?.Url }); }
/// <summary> /// Handles a form submission (sends an email). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Variables. var config = configuration as EmailConfiguration; var form = context.Form; var data = context.Data; var dataForMessage = data; var files = context.Files; var filesForMessage = files; var payload = context.Payload; var extraContext = context.ExtraContext; var extraEmails = (AttemptGetValue(extraContext, ExtraRecipientsKey) as List <string>).MakeSafe(); var extraSubject = AttemptGetValue(extraContext, ExtraSubjectKey) as string ?? string.Empty; var extraMessage = AttemptGetValue(extraContext, ExtraMessageKey) as string ?? string.Empty; var baseMessage = config.Message + extraMessage; var plainTextBody = default(string); var htmlBody = default(string); // Create message. var message = new MailMessage(); message.From = new MailAddress(config.SenderEmail); message.Subject = config.Subject + extraSubject; // Add headers to message. foreach (var header in Config.EmailHeaders) { message.Headers.Add(header.Name, header.Value); } // Get recipients from field values. var emailFieldIds = new HashSet <Guid>(config.RecipientFields); var fieldEmails = data .Where(x => emailFieldIds.Contains(x.FieldId)).SelectMany(x => x.FieldValues) .Where(x => !string.IsNullOrWhiteSpace(x)) .Where(x => IsEmailInValidFormat(x)); // Include only specific fields in the email message? if (config.FieldsToInclude.Any()) { // Variables. var fieldIdsToInclude = new HashSet <Guid>(config.FieldsToInclude); // Selected server side fields. var serverSideFields = form.Fields .Where(x => x.IsServerSideOnly) .Where(x => fieldIdsToInclude.Contains(x.Id)) .Select(x => new FieldSubmission() { FieldId = x.Id, // The values don't matter here, as the IFormFieldType.FormatValue is how server // side fields return a field value. FieldValues = Enumerable.Empty <string>() }); // Combine submitted data and server side field data. var dataWithServerSideFields = data.Concat(serverSideFields); // Filter normal fields. dataForMessage = dataWithServerSideFields .Where(x => fieldIdsToInclude.Contains(x.FieldId)).ToArray(); // Filter file fields. filesForMessage = files .Where(x => fieldIdsToInclude.Contains(x.FieldId)).ToArray(); } // Any allowed recipients (if not, abort early)? var rawRecipients = config.Recipients .Concat(fieldEmails) .Concat(extraEmails); var allowedRecipients = FilterEmails(rawRecipients); if (!allowedRecipients.Any()) { return; } foreach (var recipient in allowedRecipients) { if ("to".InvariantEquals(config.DeliveryType)) { message.To.Add(recipient); } else if ("cc".InvariantEquals(config.DeliveryType)) { message.CC.Add(recipient); } else { message.Bcc.Add(recipient); } } // Append fields? if (config.AppendFields) { var chosenPayload = config.AppendPayload ? payload : payload.Take(0); htmlBody = ConstructMessage(form, dataForMessage, filesForMessage, chosenPayload, baseMessage, config.IncludeHiddenFields, config.ExcludeFieldLabels, true); plainTextBody = ConstructMessage(form, dataForMessage, filesForMessage, chosenPayload, baseMessage, config.IncludeHiddenFields, config.ExcludeFieldLabels, false); foreach (var file in filesForMessage) { var dataStream = new MemoryStream(file.FileData); message.Attachments.Add(new Attachment(dataStream, file.FileName)); } } else { htmlBody = WebUtility.HtmlEncode(baseMessage); plainTextBody = baseMessage; } // Add plain text alternate view. var mimeType = new ContentType(MediaTypeNames.Text.Plain); var emailView = AlternateView.CreateAlternateViewFromString(plainTextBody, mimeType); message.AlternateViews.Add(emailView); // Add HTML alternate view. mimeType = new ContentType(MediaTypeNames.Text.Html); emailView = AlternateView.CreateAlternateViewFromString(htmlBody, mimeType); message.AlternateViews.Add(emailView); // Send email. using (var client = new SmtpClient()) { client.Send(message); } }
/// <summary> /// Handles a form submission (sends an email). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public override void HandleForm(FormSubmissionContext context, object configuration) { // Prepare the message. var message = PrepareEmailMessage(context, configuration as IEmailSenderRecipientConfiguration); if (message == null) { return; } // Variables. var config = configuration as DesignedEmailConfiguration; var form = context.Form; var data = context.Data; var dataForMessage = data; var files = context.Files; var filesForMessage = files; var payload = context.Payload; var extraContext = context.ExtraContext; var plainTextBody = default(string); var htmlBody = default(string); // Combine all the email recipients into a single array. var emailDataRecipients = message.To.ToArray() .Concat(message.CC.ToArray()) .Concat(message.Bcc.ToArray()) .Select(x => x.Address).Distinct() .OrderBy(x => x).ToArray(); // Create the email data to be passed to the Razor view. var emailData = new EmailData(GetFormValues(context)) { MailMessage = message, SenderEmail = config.SenderEmail, RecipientEmails = emailDataRecipients, Subject = config.Subject, Message = config.Message, Helper = new EmailDataHelper(message) }; // Generate the email subject. var path = GetViewPath(config.SubjectRazorPath); var contents = path == null ? RazorViewIncorrectMarkup(config.HtmlEmailRazorPath) : File.ReadAllText(path); var templateSource = path == null ? null : new LoadedTemplateSource(contents, path); var key = GetViewKey(path, contents); message.Subject = path == null ? config.Subject : (RazorService.RunCompile(templateSource, key, emailData.GetType(), emailData) ?? "") .Trim() .Replace("\r", string.Empty) .Replace("\n", string.Empty); // Generate the HTML for the message. path = GetViewPath(config.HtmlEmailRazorPath); contents = path == null ? RazorViewIncorrectMarkup(config.HtmlEmailRazorPath) : File.ReadAllText(path); templateSource = new LoadedTemplateSource(contents, path); key = GetViewKey(path, contents); htmlBody = RazorService.RunCompile(templateSource, key, emailData.GetType(), emailData); // Generate the text for the message. path = GetViewPath(config.TextEmailRazorPath); if (path != null) { contents = File.ReadAllText(path); templateSource = new LoadedTemplateSource(contents, path); key = GetViewKey(path, contents); plainTextBody = RazorService.RunCompile(templateSource, key, emailData.GetType(), emailData); } // Add plain text alternate view. var mimeType = new ContentType(MediaTypeNames.Text.Plain); var emailView = AlternateView.CreateAlternateViewFromString(plainTextBody ?? "", mimeType); message.AlternateViews.Add(emailView); // Add HTML alternate view. mimeType = new ContentType(MediaTypeNames.Text.Html); emailView = AlternateView.CreateAlternateViewFromString(htmlBody ?? "", mimeType); message.AlternateViews.Add(emailView); // Send email. using (var client = new SmtpClient()) { client.Send(message); } }
/// <summary> /// Handles a form submission (stores it). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Variables. var form = context.Form; var data = context.Data; var files = context.Files; var payload = context.Payload; var fieldsById = form.Fields.ToDictionary(x => x.Id, x => x); var db = context.UmbracoContext.Application.DatabaseContext.Database; // This will store the formatted values. var valueList = new[] { new { FieldId = default(string), // Field name is stored in case the field is deleted from the form // and this stored name is all we have to go on. FieldName = default(string), Value = default(string) } }.Take(0).ToList(); // Group the data values by their field ID. var valuesById = data.GroupBy(x => x.FieldId).Select(x => new { Id = x.Key, Values = x.SelectMany(y => y.FieldValues).ToList() }).ToDictionary(x => x.Id, x => x.Values); // Store the file values by their field ID. var filesById = files.GroupBy(x => x.FieldId).Select(x => new { Id = x.Key, Filename = x.Select(y => y.FileName).FirstOrDefault(), PathSegment = GenerateFilePathSegment(), FileData = x.Select(y => y.FileData).FirstOrDefault() }).ToDictionary(x => x.Id, x => x); // Normal fields. foreach (var key in valuesById.Keys) { var values = valuesById[key]; var formatted = string.Join(", ", values); var field = default(IFormField); var fieldName = default(string); if (fieldsById.TryGetValue(key, out field)) { formatted = field.FormatValue(values, FieldPresentationFormats.Storage); fieldName = field.Name; } valueList.Add(new { FieldId = GuidHelper.GetString(key), FieldName = fieldName, Value = formatted }); } // Store file information for serialization. var fileList = filesById.Values.Select(x => new { FieldId = GuidHelper.GetString(x.Id), // Field name is stored in case the field is deleted from the form // and this stored name is all we have to go on. FieldName = GetFieldName(x.Id, fieldsById), PathSegment = x.PathSegment, Filename = x.Filename }); // Store the files. if (files.Any()) { // Ensure base path exists. var basePath = HostingEnvironment.MapPath(Config.FileStoreBasePath); if (!Directory.Exists(basePath)) { Directory.CreateDirectory(basePath); } // Create files. foreach (var key in filesById.Keys) { var file = filesById[key]; var fullPath = Path.Combine(basePath, file.PathSegment); var pathOnly = Path.GetDirectoryName(fullPath); Directory.CreateDirectory(pathOnly); File.WriteAllBytes(fullPath, file.FileData); } } // Store data to database. var serializedValues = JsonHelper.Serialize(valueList.ToArray()); var serializedFiles = JsonHelper.Serialize(fileList.ToArray()); db.Insert(new FormulateSubmission() { CreationDate = DateTime.UtcNow, DataValues = serializedValues, FileValues = serializedFiles, FormId = form.Id, GeneratedId = context.SubmissionId, PageId = context?.CurrentPage?.Id, Url = context?.CurrentPage?.Url }); }
/// <summary> /// Prepares to handle to form submission. /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> /// <remarks> /// In this case, no preparation is necessary. /// </remarks> public void PrepareHandleForm(FormSubmissionContext context, object configuration) { }
/// <summary> /// Submits a form. /// </summary> /// <param name="formId"> /// The ID of the form to submit. /// </param> /// <param name="data"> /// The form data to submit. /// </param> /// <param name="files"> /// The file data to submit. /// </param> /// <param name="payload"> /// Extra data related to the submission. /// </param> /// <param name="options"> /// The options for this submission. /// </param> /// <param name="context"> /// The contextual information for the form request. /// </param> /// <returns> /// The result of the submission. /// </returns> public static SubmissionResult SubmitForm(Guid formId, IEnumerable <FieldSubmission> data, IEnumerable <FileFieldSubmission> files, IEnumerable <PayloadSubmission> payload, SubmissionOptions options, FormRequestContext context) { // Is the form ID valid? var form = Forms.Retrieve(formId); if (form == null) { return(new SubmissionResult() { Success = false }); } // Create submission context. var submissionContext = new FormSubmissionContext() { Files = files, Data = data, Form = form, Payload = payload, CurrentPage = context.CurrentPage, HttpContext = context.HttpContext, Services = context.Services, UmbracoContext = context.UmbracoContext, UmbracoHelper = context.UmbracoHelper, SubmissionId = Guid.NewGuid(), ExtraContext = new Dictionary <string, object>() }; // Invoke submitting event (gives listeners a chance to change the submission). Submitting?.Invoke(submissionContext); // Validate? if (options.Validate) { var valuesById = data.GroupBy(x => x.FieldId).Select(x => new { Id = x.Key, Values = x.SelectMany(y => y.FieldValues).ToList() }).ToDictionary(x => x.Id, x => x.Values); foreach (var field in form.Fields) { var validations = field.Validations.Select(x => Validations.Retrieve(x)).ToList(); foreach (var validation in validations) { //TODO: var validationResult = validation.Validate(form, field, valuesById); } } } // Prepare the form handlers. // This occurs on the current thread in case the handler needs information // only available in the current thread. try { foreach (var handler in form.Handlers) { handler.PrepareHandleForm(submissionContext); } } catch (Exception ex) { LogHelper.Error <Submissions_Instance>(PreHandlerError, ex); return(new SubmissionResult() { Success = false }); } // Initiate form handlers on a new thread (they may take some time to complete). var t = new Thread(() => { try { foreach (var handler in form.Handlers) { handler.HandleForm(submissionContext); } } catch (Exception ex) { LogHelper.Error <Submissions_Instance>(HandlerError, ex); } }); t.IsBackground = true; t.Start(); // Return success. return(new SubmissionResult() { Success = true }); }
/// <summary> /// Sends a web request with the data either in the query string or in the body. /// </summary> /// <param name="config"> /// The configuration for the data to be sent (e.g., contains the URL and request method). /// </param> /// <param name="context"> /// The context for the current form submission. /// </param> /// <param name="data"> /// The data to send. /// </param> /// <param name="sendInBody"> /// Send the data as part of the body (or in the query string)? /// </param> /// <param name="sendJson"> /// Send the data as json /// </param> /// <returns> /// True, if the request was a success; otherwise, false. /// </returns> /// <remarks> /// Parts of this function are from: http://stackoverflow.com/a/9772003/2052963 /// and http://stackoverflow.com/questions/14702902 /// </remarks> private SendDataResult SendData(SendDataConfiguration config, FormSubmissionContext context, IEnumerable <KeyValuePair <string, string> > data, bool sendInBody, bool sendJson) { // Construct a URL, possibly containing the data as query string parameters. var sendInUrl = !sendInBody; var sendDataResult = new SendDataResult(); var uri = new Uri(config.Url); var bareUrl = uri.GetLeftPart(UriPartial.Path); var keyValuePairs = data as KeyValuePair <string, string>[] ?? data.ToArray(); var strQueryString = ConstructQueryString(uri, keyValuePairs); var hasQueryString = !string.IsNullOrWhiteSpace(strQueryString); var requestUrl = hasQueryString && sendInUrl ? $"{bareUrl}?{strQueryString}" : config.Url; var enableLogging = WebConfigurationManager.AppSettings["Formulate:EnableLogging"]; var jsonMode = WebConfigurationManager.AppSettings["Formulate:Send Data JSON Mode"]; var isJsonObjectMode = "JSON Object".InvariantEquals(jsonMode); var isWrappedObjectMode = "Wrap JSON Object in Array".InvariantEquals(jsonMode); // Attempt to send the web request. try { // Construct web request. var request = (HttpWebRequest)WebRequest.Create(requestUrl); request.AllowAutoRedirect = false; request.UserAgent = WebUserAgent; request.Method = config.Method; // Send an event indicating that the data is about to be sent (which allows code // external to Formulate to modify the request). var sendContext = new SendingDataContext() { Configuration = config, Data = keyValuePairs, Request = request, SubmissionContext = context }; SendingData?.Invoke(sendContext); // Update the key/value pairs in case they got changed in the sending data event. // This only updates the methods that send the data in the body (as the URL has // already been set on the request). keyValuePairs = sendContext.Data as KeyValuePair <string, string>[] ?? sendContext.Data.ToArray(); // Send the data in the body (rather than the query string)? if (sendInBody) { if (sendJson) { // Variables. var json = default(string); // Send an event indicating that the data is about to be serialized to // JSON (which allows code external to Formulate to modify the JSON)? if (SerializingJson != null) { json = SerializingJson.Invoke(sendContext.Data); } else { // If sending as JSON, group duplicate keys/value pairs. var grouped = keyValuePairs.GroupBy(x => x.Key).Select(x => new { Key = x.Key, Value = x.Select(y => y.Value) }).ToDictionary(x => x.Key, x => x.Value.Count() > 1 ? x.Value.ToArray() as object : x.Value.FirstOrDefault()); // Convert data to JSON. if (isJsonObjectMode) { json = JsonConvert.SerializeObject(grouped); } else if (isWrappedObjectMode) { json = JsonConvert.SerializeObject(new[] { grouped }); } else { // Ideally, we can remove this "else" branch later. We never really want this // mode to be used, but it's here for legacy support in case anybody managed // to make use of this funky mode. json = JsonConvert.SerializeObject(new[] { grouped }); } } // Log JSON being sent. if (enableLogging == "true") { LogHelper.Info <SendDataHandler>("Sent URL: " + config.Url); LogHelper.Info <SendDataHandler>("Sent Data: " + JsonHelper.FormatJsonForLogging(json)); } // Write JSON data to the request request. var postBytes = Encoding.UTF8.GetBytes(json); request.ContentType = "application/json; charset=utf-8"; request.ContentLength = postBytes.Length; using (var postStream = request.GetRequestStream()) { postStream.Write(postBytes, 0, postBytes.Length); } } else { // Log data being sent. if (enableLogging == "true") { LogHelper.Info <SendDataHandler>("Sent URL: " + config.Url); LogHelper.Info <SendDataHandler>("Sent Data: " + strQueryString); } // Update the data (since the sending data event may have modified it). uri = new Uri(config.Url); strQueryString = ConstructQueryString(uri, keyValuePairs); // Write the data to the request stream. var postBytes = Encoding.UTF8.GetBytes(strQueryString); request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = postBytes.Length; var postStream = request.GetRequestStream(); postStream.Write(postBytes, 0, postBytes.Length); } } // Get and retain response. var response = (HttpWebResponse)request.GetResponse(); sendDataResult.HttpWebResponse = response; var responseStream = response.GetResponseStream(); var reader = new StreamReader(responseStream); var resultText = reader.ReadToEnd(); sendDataResult.ResponseText = resultText; sendDataResult.Success = true; } catch (Exception ex) { LogHelper.Error <SendDataHandler>(SendDataError, ex); sendDataResult.ResponseError = ex; sendDataResult.Success = false; } // Return the result of the request. return(sendDataResult); }
/// <summary> /// Handles a form submission (sends an email). /// </summary> /// <param name="context"> /// The form submission context. /// </param> /// <param name="configuration"> /// The handler configuration. /// </param> public void HandleForm(FormSubmissionContext context, object configuration) { // Variables. var form = context.Form; var data = context.Data; var files = context.Files; var payload = context.Payload; // Create message. var config = configuration as EmailConfiguration; var message = new MailMessage() { IsBodyHtml = false }; message.From = new MailAddress(config.SenderEmail); message.Subject = config.Subject; // Any allowed recipients (if not, abort early)? var allowedRecipients = FilterEmails(config.Recipients); if (!allowedRecipients.Any()) { return; } foreach (var recipient in allowedRecipients) { message.To.Add(recipient); } // Append fields? if (config.AppendFields) { var chosenPayload = config.AppendPayload ? payload : payload.Take(0); message.Body = ConstructMessage(form, data, files, chosenPayload, config); foreach(var file in files) { var dataStream = new MemoryStream(file.FileData); message.Attachments.Add(new Attachment(dataStream, file.FileName)); } } else { message.Body = config.Message; } // Send email. using (var client = new SmtpClient()) { client.Send(message); } }