UpdateAccount.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Service.IoTBroker.DataStorage;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class UpdateAccount : HttpSynchronousResource, IHttpPostMethod
    {
        public UpdateAccount()
            : base("/UpdateAccount")
        {
        }
 
        public override bool HandlesSubPaths => false;
        public override bool UserSessions => true;
        public bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, "Admin.Broker.Accounts");
 
            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;
            }
 
            CaseInsensitiveString UserName;
            string Password;
            CaseInsensitiveString EMail;
            CaseInsensitiveString PhoneNr;
            string[] RoleIds;
            string FtpRootFolder;
            bool Enabled;
            bool CanRelayMessages;
            bool FtpCanRead;
            bool FtpCanWrite;
 
            if (!Form.ContainsKey("UserName") || CaseInsensitiveString.IsNullOrEmpty(UserName = Form["UserName"]))
            {
                await Response.SendResponse(new BadRequestException("Missing user name."));
                return;
            }
 
            if (!Form.ContainsKey("Password"))
                Password = null;
            else
                Password = Form["Password"];
 
            if (!Form.ContainsKey("EMail") || CaseInsensitiveString.IsNullOrEmpty(EMail = Form["EMail"]))
            {
                await Response.SendResponse(new BadRequestException("Missing e-Mail address."));
                return;
            }
 
            if (!Form.ContainsKey("PhoneNr"))
            {
                await Response.SendResponse(new BadRequestException("Missing phone number field."));
                return;
            }
 
            PhoneNr = Form["PhoneNr"];
 
            if (!Form.ContainsKey("Enabled"))
                Enabled = false;
            else if (!CommonTypes.TryParse(Form["Enabled"], out Enabled))
            {
                await Response.SendResponse(new BadRequestException("Invalid value."));
                return;
            }
 
            if (!Form.ContainsKey("CanRelayMessages"))
                CanRelayMessages = false;
            else if (!CommonTypes.TryParse(Form["CanRelayMessages"], out CanRelayMessages))
            {
                await Response.SendResponse(new BadRequestException("Invalid value."));
                return;
            }
 
            if (!Form.ContainsKey("FtpRootFolder"))
            {
                await Response.SendResponse(new BadRequestException("Missing FTP Root folder field."));
                return;
            }
 
            FtpRootFolder = Form["FtpRootFolder"];
            if (!string.IsNullOrEmpty(FtpRootFolder) && !Directory.Exists(FtpRootFolder))
            {
                await Response.SendResponse(new BadRequestException("FTP Root folder does not exist or is not reachable."));
                return;
            }
 
            long? FtpMaxStorage;
 
            if (!Form.ContainsKey("FtpMaxStorage"))
                FtpMaxStorage = null;
            else
            {
                string s = Form["FtpMaxStorage"];
 
                if (string.IsNullOrEmpty(s))
                    FtpMaxStorage = null;
                else if (!long.TryParse(Form["FtpMaxStorage"], out long l) || l < 0)
                {
                    await Response.SendResponse(new BadRequestException("Invalid value."));
                    return;
                }
                else
                    FtpMaxStorage = l;
            }
 
            if (!Form.ContainsKey("FtpCanRead"))
                FtpCanRead = false;
            else if (!CommonTypes.TryParse(Form["FtpCanRead"], out FtpCanRead))
            {
                await Response.SendResponse(new BadRequestException("Invalid value."));
                return;
            }
 
            if (!Form.ContainsKey("FtpCanWrite"))
                FtpCanWrite = false;
            else if (!CommonTypes.TryParse(Form["FtpCanWrite"], out FtpCanWrite))
            {
                await Response.SendResponse(new BadRequestException("Invalid value."));
                return;
            }
 
            if ((FtpCanRead || FtpCanWrite) && string.IsNullOrEmpty(FtpRootFolder))
            {
                await Response.SendResponse(new BadRequestException("FTP Root folder not provided."));
                return;
            }
 
            if (!Form.TryGetValue("Roles", out string Roles))
                Roles = string.Empty;
 
            RoleIds = Roles.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);
 
            PersistenceLayer PersistenceLayer = XmppServerModule.PersistenceLayer ?? new PersistenceLayer();
            Account Account = await PersistenceLayer.GetAccountEx(UserName);
            if (Account is null)
            {
                await Response.SendResponse(new NotFoundException());
                return;
            }
 
            if (!string.IsNullOrEmpty(Password))
                Account.Password = Password;
 
            if (Account.EMail != EMail)
            {
                Account.EMail = EMail;
                Account.EMailVerified = null;
            }
 
            if (Account.PhoneNr != PhoneNr)
            {
                Account.PhoneNr = PhoneNr;
                Account.PhoneNrVerified = null;
            }
 
            Account.Enabled = Enabled;
            Account.CanRelayMessages = CanRelayMessages;
            Account.FtpRootFolder = FtpRootFolder;
            Account.FtpMaxStorage = FtpMaxStorage;
            Account.FtpCanRead = FtpCanRead;
            Account.FtpCanWrite = FtpCanWrite;
            Account.RoleIds = RoleIds;
            Account.Updated = DateTime.UtcNow;
 
            await Database.Update(Account);
 
            if (!(Request.Header.Referer is null))
                await Response.SendResponse(new SeeOtherException(Request.Header.Referer.Value));  // PRG pattern.
        }
    }
}