Feedback.cs

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Markdown;
using Waher.Networking.HTTP;
using Waher.Security.LoginMonitor;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class Feedback : HttpSynchronousResource, IHttpPostMethod
    {
        public Feedback()
            : base("/Feedback")
        {
        }
 
        public override bool HandlesSubPaths => false;
        public override bool UserSessions => true;
        public bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            if (!Request.HasData)
                throw new BadRequestException();
 
            object Obj = await Request.DecodeDataAsync();
            if (!(Obj is Dictionary<string, string> Form))
                throw new BadRequestException();
 
            string Name;
            string EMail;
            string Reason;
            string Text;
            string RecaptchaResponse;
            bool ResponseDesired;
 
            if (!Form.ContainsKey("Name") || string.IsNullOrEmpty(Name = Form["Name"]?.Trim()))
                throw new BadRequestException();
 
            if (!Form.ContainsKey("EMail") || string.IsNullOrEmpty(EMail = Form["EMail"]?.Trim()))
                throw new BadRequestException();
 
            if (!Form.ContainsKey("Reason") || string.IsNullOrEmpty(Reason = Form["Reason"]?.Trim()))
                throw new BadRequestException();
 
            if (!Form.ContainsKey("Text") || string.IsNullOrEmpty(Text = Form["Text"]?.Trim()))
                throw new BadRequestException();
 
            if (!Form.ContainsKey("g-recaptcha-response") || string.IsNullOrEmpty(RecaptchaResponse = Form["g-recaptcha-response"]))
                throw new BadRequestException();
 
            if (!Form.ContainsKey("ResponseDesired"))
                ResponseDesired = false;
            else if (!CommonTypes.TryParse(Form["ResponseDesired"], out ResponseDesired))
                throw new BadRequestException();
 
            if (await SiteVerify(RecaptchaResponse, Request.RemoteEndPoint))
            {
                KeyValuePair<string, object>[] Tags = await LoginAuditor.Annotate(Request.RemoteEndPoint,
                    new KeyValuePair<string, object>("Name", Name),
                    new KeyValuePair<string, object>("EMail", EMail),
                    new KeyValuePair<string, object>("Reason", Reason),
                    new KeyValuePair<string, object>("Text", Text),
                    new KeyValuePair<string, object>("ResponseDesired", ResponseDesired),
                    new KeyValuePair<string, object>("RemoteEndPoint", Request.RemoteEndPoint));
 
                Dictionary<string, object> Feedback = new Dictionary<string, object>();
                foreach (KeyValuePair<string, object> P in Tags)
                    Feedback.Add(P.Key, P.Value);
 
                Request.Session["Feedback"] = Feedback;
 
                StringBuilder Markdown = new StringBuilder();
                DateTime Now = DateTime.Now;
 
                Markdown.AppendLine("Feedback received.");
                Markdown.AppendLine();
 
                Markdown.AppendLine("| Feedback ||");
                Markdown.AppendLine("|:------|:-------|");
 
                Markdown.Append("| Name: | ");
                Markdown.Append(MarkdownDocument.Encode(Name));
                Markdown.AppendLine(" |");
 
                Markdown.Append("| e-Mail: | <a href=\"mailto:");
                Markdown.Append(EMail.Replace("\"", "&quot;"));
                Markdown.Append("\" target=\"_blank\">");
                Markdown.Append(MarkdownDocument.Encode(EMail));
                Markdown.AppendLine("</a> |");
 
                Markdown.Append("| Reason: | ");
                Markdown.Append(MarkdownDocument.Encode(Reason));
                Markdown.AppendLine(" |");
 
                Markdown.Append("| Response desired: | ");
                if (ResponseDesired)
                    Markdown.Append(":white_check_mark:");
                else
                    Markdown.Append(":negative_squared_cross_mark:");
                Markdown.AppendLine(" |");
 
                await XmppServerModule.AppendRemoteEndpointToTable(Markdown, Request.RemoteEndPoint);
 
                Markdown.Append("| Date | ");
                Markdown.Append(MarkdownDocument.Encode(Now.ToShortDateString()));
                Markdown.AppendLine(" |");
                Markdown.Append("| Time | ");
                Markdown.Append(MarkdownDocument.Encode(Now.ToLongTimeString()));
                Markdown.AppendLine(" |");
 
                Markdown.AppendLine();
                Markdown.AppendLine();
                Markdown.AppendLine("```");
                Markdown.AppendLine(Text.Replace("```", " ` ` ` "));
                Markdown.AppendLine("```");
 
                await LoginAuditor.AppendWhoIsInfo(Markdown, Request.RemoteEndPoint);
 
                await IoTGateway.Gateway.SendNotification(Markdown.ToString());
 
                throw new SeeOtherException("/FeedbackSent.md");  // PRG pattern.
            }
            else
                throw new ForbiddenException("Request not verified. Bot?");
        }
 
        internal static async Task<bool> SiteVerify(string RecaptchaResponse, string RemoteEndPoint)
        {
            using (HttpClient WebClient = new HttpClient())
            {
                Dictionary<string, string> VerificationForm = new Dictionary<string, string>()
                    {
                        { "secret", "6LcHNh0UAAAAAI1DwveBT21M4IkSRc5i-QciPUvg" },   // TODO: Make configurable.
                        { "response", RecaptchaResponse },
                        { "remoteip", RemoteEndPoint }
                    };
 
                HttpContent Content = new FormUrlEncodedContent(VerificationForm);
                HttpResponseMessage ResponseMsg = await WebClient.PostAsync("https://www.google.com/recaptcha/api/siteverify", Content);
                if (!ResponseMsg.IsSuccessStatusCode)
                    throw new ServiceUnavailableException();
 
                string Json = await ResponseMsg.Content.ReadAsStringAsync();
                return (JSON.Parse(Json) is Dictionary<string, object> Parsed && Parsed.ContainsKey("success") && Parsed["success"] is bool Success && Success);
            }
        }
 
    }
}