RequestAccount.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Markdown;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Security.LoginMonitor;
using Waher.Service.IoTBroker.Setup;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class RequestAccount : HttpSynchronousResource, IHttpPostMethod
    {
        public RequestAccount()
            : base("/RequestAccount")
        {
        }
 
        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;
            CaseInsensitiveString EMail;
            string LinkedIn;
            string Organization;
            string Where;
            string TimeLimit;
            string Text;
            string RecaptchaResponse;
 
            if (!Form.ContainsKey("Name") || string.IsNullOrEmpty(Name = Form["Name"]))
            {
                await Response.SendResponse(new BadRequestException("Name missing."));
                return;
            }
 
            if (!Form.ContainsKey("EMail") || CaseInsensitiveString.IsNullOrEmpty(EMail = Form["EMail"]))
            {
                await Response.SendResponse(new BadRequestException("E-mail missing."));
                return;
            }
 
            if (!Form.ContainsKey("LinkedIn") || string.IsNullOrEmpty(LinkedIn = Form["LinkedIn"]))
            {
                await Response.SendResponse(new BadRequestException("LinkedIn link missing."));
                return;
            }
 
            if (!Form.ContainsKey("Organization") || string.IsNullOrEmpty(Organization = Form["Organization"]))
            {
                await Response.SendResponse(new BadRequestException("Organization missing."));
                return;
            }
 
            if (!Form.ContainsKey("Where") || string.IsNullOrEmpty(Where = Form["Where"]))
            {
                await Response.SendResponse(new BadRequestException("Where reference missing."));
                return;
            }
 
            if (!Form.ContainsKey("TimeLimit") || string.IsNullOrEmpty(TimeLimit = Form["TimeLimit"]))
                TimeLimit = string.Empty;
 
            if (!Form.ContainsKey("Text") || string.IsNullOrEmpty(Text = Form["Text"]))
            {
                await Response.SendResponse(new BadRequestException("Reason missing."));
                return;
            }
 
            if (!Form.ContainsKey("g-recaptcha-response") || string.IsNullOrEmpty(RecaptchaResponse = Form["g-recaptcha-response"]))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (await Feedback.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.Value),
                    new KeyValuePair<string, object>("LinkedIn", LinkedIn),
                    new KeyValuePair<string, object>("Organization", Organization),
                    new KeyValuePair<string, object>("Where", Where),
                    new KeyValuePair<string, object>("TimeLimit", TimeLimit),
                    new KeyValuePair<string, object>("Text", Text),
                    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("Account requested.");
                Markdown.AppendLine();
 
                Markdown.AppendLine("| Account request ||");
                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("| LinkedIn: | <a href=\"");
                Markdown.Append(LinkedIn.Replace("\"", "&quot;"));
                Markdown.Append("\" target=\"_blank\">");
                Markdown.Append(MarkdownDocument.Encode(LinkedIn));
                Markdown.AppendLine("</a> |");
 
                Markdown.Append("| Organization: | ");
                Markdown.Append(MarkdownDocument.Encode(Organization));
                Markdown.AppendLine(" |");
 
                Markdown.Append("| Where: | ");
                Markdown.Append(MarkdownDocument.Encode(Where));
                Markdown.AppendLine(" |");
 
                Markdown.Append("| Time Limit: | ");
                Markdown.Append(MarkdownDocument.Encode(TimeLimit));
                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?.AccountRequested ?? false)
                    await IoTGateway.Gateway.SendNotification(Markdown.ToString());
                else
                    Log.Notice(Markdown.ToString(), Tags);
 
                await Response.SendResponse(new SeeOtherException("/AccountRequested.md"));  // PRG pattern.
            }
            else
                await Response.SendResponse(new ForbiddenException(Request, "Request not verified. Bot?"));
        }
    }
}