test/CDPShared/CDPWorker.cs

using System.Net.Http.Headers;
using CircleSDK.Model;
using Newtonsoft.Json;
using System.Reflection;
using System.Reflection.Metadata.Ecma335;
using System.Reflection.PortableExecutable;

namespace CDPShared
{
    // All the code in this file is included in all platforms.
    public class CDPWorker
    {
        private CircleAPIHelper _apiHelper;
        private string _userName = "";
        private string _machine = "";

        Boolean _bReady = false;
        public Boolean Ready => _bReady;
        public string Status
        {
            get
            {
                return _apiHelper.Status;
            }
        }

//        public CircleAPIHelper API => _apiHelper;

        public List<CircleInfo> Circles { get; set; }

        public string DefaultTopicId { get; set; } = "87654321-a314-4202-b959-c981a6bc3c24";
        public string DefaultCircleId { get; set; }

        public CDPWorker()
        {
            using (LogMethod.Log(MethodBase.GetCurrentMethod().ReflectedType.Name))
            {
                Circles = new List<CircleInfo>();
                
                _apiHelper = new CircleAPIHelper(Constants.CustomerCode, Constants.AppKey, Constants.EndUserId, Constants.Secret);
                _userName = Environment.UserDomainName + "\\" + Environment.UserName;
                _machine = Environment.MachineName;
                Task.Run(async () => {await AsyncStartup(); });
            }
        }

        async Task AsyncStartup()
        {
            while (!_apiHelper.Ready)
            {
                Thread.Sleep(250);
            }

            Circles = await _apiHelper.EnumCircles();
            _bReady = true;
        }

        public async Task<DecryptReply> Decrypt(string file)
        {
            YellowFile yf = new YellowFile(file);

            DecryptRequest request = new DecryptRequest();
            request.CircleId = yf.CircleId;
            request.TopicId = yf.TopicId;
            request.ToDecrypt = Convert.ToBase64String(File.ReadAllBytes(file));
            DecryptReply result = null;
            result = await _apiHelper.Api.DecryptAsync(request, "Bearer " + _apiHelper.Token, "Dashboard");
            if (!result.Status.Result.GetValueOrDefault(false))
                return null;

            return result;
        }

        public async Task<CreateCircleReply> CreateCircle(string name, string description)
        {
            return await _apiHelper.CreateCircle(name, description);
        }

        public async Task<GenInviteReply> GenInvite(string circleId)
        {
            return await _apiHelper.GenInvite(circleId);
        }

        public async Task<ProcessInviteReply> ProcessInvite(string inviteCode, string authCode)
        {
            return await _apiHelper.ProcessInvite(inviteCode, authCode);
        }

        public async Task<RemoveMemberReply> RemoveMember(string circleId, string memberId)
        {
            return await _apiHelper.RemoveMember(circleId, memberId);
        }

        public async Task<List<ProfileInfo>> EnumCircleMembers(string circleId)
        {
            return await _apiHelper.EnumCircleMembers(circleId);
        }

        public async Task<CircleInfo> GetCircle(string circleId)
        {
            return await _apiHelper.GetCircleById(circleId);
        }

        public async Task<TopicInfo> GetTopic(string circleId, string topicId)
        {
            return await _apiHelper.GetTopicById(circleId, topicId);
        }

        public async Task TrackAuthorizedAccess(YellowFile yf, string fileName, Dictionary<string, string> metaData)
        {
            using (LogMethod.Log(MethodBase.GetCurrentMethod().ReflectedType.Name))
            {
                try
                {
                    DataGather g = new DataGather(_apiHelper);
                    foreach (KeyValuePair<string, string> keyValuePair in metaData)
                    {
                        g.AddHead(keyValuePair.Key, keyValuePair.Value);
                    }
                    g.AddTail("File Id", yf.FileId);

                    WhoAmIReply wr = await _apiHelper.WhoAmI(yf.CircleId);
                    List<ProfileInfo> members = await _apiHelper.EnumCircleMembers(yf.CircleId);

                    string senderName = yf.OwnerId;
                    ProfileInfo sender = members.FirstOrDefault(dr => dr.ProfileId == yf.OwnerId);
                    if (sender != null)
                        senderName = sender.DisplayName;

                    g.AddHead("Sender", senderName);
                    g.AddTail("Sender Id", yf.OwnerId);

                    string viewerName = "";
                    ProfileInfo viewer = members.FirstOrDefault(dr => dr.ProfileId == wr.MemberId);
                    if (viewer != null)
                        viewerName = viewer.DisplayName;

                    g.AddHead("Viewer", viewerName);
                    g.AddTail("Viewer Id", wr.MemberId);

                    yf.UpdateOwner(wr.MemberId);

                    await AddMessage($"{fileName} decrypted by {_userName}", (Int32)CircleViewMessages.FileViewed, g);
                }
                catch (Exception e)
                {
                    MinLogging.LogIt(e.Message);
                }
            }

        }
        public async Task TrackUnauthorizedAccess(YellowFile yf, string sourcePath)
        {
            using (LogMethod.Log(MethodBase.GetCurrentMethod().ReflectedType.Name))
            {
                try
                {
                    DataGather g = new DataGather(_apiHelper);
                    g.AddHead($"Full path", sourcePath);
                    g.AddTail("File Id", yf.FileId);

                    string senderName = yf.OwnerId;
                    g.AddTail("Sender Id", yf.OwnerId);

                    string message = $"{_userName} was blocked attempting to view a protected file"; // we can't use the filename since it's in the encrypted header

                    await PostCircleViewEvent(yf.CircleId, yf.FileId, (Int32)CircleViewMessages.BlockedViewAttempt, message, JsonConvert.SerializeObject(g.Gather()));
                }
                catch (Exception e)
                {
                    MinLogging.LogIt(e.Message);
                }
            }
        }
        async Task PostCircleViewEvent(string circleId, string fileId, Int32 msgType, string message, string meta)
        {
            using (LogMethod.Log(MethodBase.GetCurrentMethod().ReflectedType.Name))
            {
                var url = Constants.CircleViewEventUrl + "?circleId=" + circleId;
                var data = new
                {
                    FileId = fileId,
                    MsgId = Guid.NewGuid().ToString(),
                    Event = DateTime.UtcNow,
                    MsgType = msgType,
                    Message = message,
                    Meta = meta
                };

                try
                {
                    HttpClient client = new HttpClient();
                    var json = JsonConvert.SerializeObject(data);
                    var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

                    MinLogging.LogIt(url);
                    MinLogging.LogIt(json);

                    var response = await client.PostAsync(url, content);

                    response.EnsureSuccessStatusCode();
                    string result = await response.Content.ReadAsStringAsync();
                    MinLogging.LogIt(result);
                }
                catch (Exception e)
                {
                    MinLogging.LogIt(" **** " + e.Message);
                }
            }
        }

        public async Task<List<TopicInfo>> EnumTopics(string circleId)
        {
            return await _apiHelper.EnumTopics(circleId);
        }

        public async Task<byte[]> EncryptFile(string circleId, string topicId, string fileName)
        {
            return await _apiHelper.EncryptFile(circleId, topicId, fileName);
        }
        /// <summary>
        /// this adds a message to the default circle and topic
        /// </summary>
        public async Task<AddMessageReply> AddMessage(string message, Int32 msgId, DataGather g = null)
        {
            return await _apiHelper.AddMessage(DefaultCircleId, DefaultTopicId, message, msgId, g);
        }
        public async Task<GetMessagesReply> GetCircleViewMessages(string circleId = "", string topicId = "")
        {
            if (string.IsNullOrEmpty(circleId)) circleId = DefaultCircleId;
            if (string.IsNullOrEmpty(topicId)) topicId = DefaultTopicId;
            return await _apiHelper.GetCircleViewwMessages(circleId, topicId);
        }

    }
}