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.Events;
using Waher.Networking.HTTP;
using Waher.Security.LoginMonitor;
using Waher.Service.IoTBroker.Setup;
 
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)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            if (Content.HasError || !(Content.Decoded is Dictionary<string, string> Form))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            string Name;
            string EMail;
            string Reason;
            string Text;
            string RecaptchaResponse;
            bool ResponseDesired;
 
            if (!Form.ContainsKey("Name") || string.IsNullOrEmpty(Name = Form["Name"]?.Trim()))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.ContainsKey("EMail") || string.IsNullOrEmpty(EMail = Form["EMail"]?.Trim()))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.ContainsKey("Reason") || string.IsNullOrEmpty(Reason = Form["Reason"]?.Trim()))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.ContainsKey("Text") || string.IsNullOrEmpty(Text = Form["Text"]?.Trim()))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.ContainsKey("g-recaptcha-response") || string.IsNullOrEmpty(RecaptchaResponse = Form["g-recaptcha-response"]))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.ContainsKey("ResponseDesired"))
                ResponseDesired = false;
            else if (!CommonTypes.TryParse(Form["ResponseDesired"], out ResponseDesired))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            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);
 
                if (BrokerNotificationConfiguration.Instance?.FeedbackReceived ?? false)
                    await IoTGateway.Gateway.SendNotification(Markdown.ToString());
                else
                    Log.Notice(Markdown.ToString(), Tags);
 
                await Response.SendResponse(new SeeOtherException("/FeedbackSent.md"));  // PRG pattern.
            }
            else
                await Response.SendResponse(new ForbiddenException(Request, "Request not verified. Bot?"));
        }
 
        public 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;
        }
 
    }
}