com.xd.sdk.report 0.0.1

package/Editor/XD.SDK.Report.Editor.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "XD.SDK.Report.Editor",
+    "references": [
+        "GUID:616cea76def2d4f059b94440fc8cc03d",
+        "GUID:747e53b1749584bae9386571797e5eb5"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Editor/XD.SDK.Report.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: eeec22ce273654fd3a76e1135ab8647b
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/XDReportProcessBuild.cs

@@ -0,0 +1,19 @@
+using System;
+using TapTap.Common.Editor;
+using UnityEditor.Build.Reporting;
+
+namespace XD.SDK.Report.Editor
+{
+    public class XDReportProcessBuild : SDKLinkProcessBuild
+    {
+        public override int callbackOrder => 9;
+        public override string LinkPath => "XDSDK/Gen/Report/link.xml";
+
+        public override LinkedAssembly[] LinkedAssemblies => new LinkedAssembly[]
+        {
+            new LinkedAssembly { Fullname = "XD.SDK.Report" }
+        };
+
+        public override Func<BuildReport, bool> IsTargetPlatform => (report) => true;
+    }
+}

package/Editor/XDReportProcessBuild.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fe95b03b21994758b60af59e1159592a
+timeCreated: 1715590618

package/Editor.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1699939c34e140d89ef4ef277899ba35
+timeCreated: 1715590554

package/Runtime/Internal/EvidenceInfo.cs

@@ -0,0 +1,21 @@
+using LC.Newtonsoft.Json;
+
+namespace XD.SDK.Report.Internal
+{
+    public class EvidenceInfo
+    {
+        [JsonProperty("name")]
+        public string Name { get; }
+        [JsonProperty("uri")]
+        public string Uri { get; }
+        [JsonProperty("size")]
+        public long Size { get; }
+
+        public EvidenceInfo(string name, string uri, long size)
+        {
+            Name = name;
+            Uri = uri;
+            Size = size;
+        }
+    }
+}

package/Runtime/Internal/EvidenceInfo.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 31caaf981ad3439a8319e6f31bd9ffa6
+timeCreated: 1716176408

package/Runtime/Internal/IReport.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace XD.SDK.Report.Internal
+{
+    public interface IReport
+    {
+        void Report(Action<bool> resultAction);
+    }
+}

package/Runtime/Internal/IReport.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d32421600e0c4193bd75c6b02cfae53c
+timeCreated: 1715592228

package/Runtime/Internal/ReportParamsInternal.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using LC.Newtonsoft.Json;
+
+namespace XD.SDK.Report.Internal
+{
+    public class ReportParamsInternal
+    {
+        [JsonProperty("reporter")]
+        public UserInfo Reporter;
+        [JsonProperty("reportee")]
+        public UserInfo Reportee;
+        [JsonProperty("reasons")]
+        public List<ReasonParam> ReasonParams;
+        [JsonProperty("user_description", NullValueHandling = NullValueHandling.Ignore)]
+        public string UserDescription;
+        [JsonProperty("evidence", NullValueHandling = NullValueHandling.Ignore)]
+        public List<EvidenceInfo> Evidence;
+        [JsonProperty("extras", NullValueHandling = NullValueHandling.Ignore)]
+        public string Extras;
+
+        public class UserInfo
+        {
+            [JsonProperty("xdid")]
+            public string XdId { get; }
+            [JsonProperty("extras", NullValueHandling = NullValueHandling.Ignore)]
+            public string Extras { get; }
+
+            public UserInfo(string xdId, string extras)
+            {
+                XdId = xdId;
+                Extras = extras;
+            }
+        }
+
+        public class ReasonParam
+        {
+            [JsonProperty("id")]
+            public long ID;
+            [JsonProperty("title", NullValueHandling = NullValueHandling.Ignore)]
+            public string Title;
+            [JsonProperty("extras", NullValueHandling = NullValueHandling.Ignore)]
+            public string Extras;
+        }
+    }
+}

package/Runtime/Internal/ReportParamsInternal.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b967b5d16e0840ed883df2be72237487
+timeCreated: 1716177475

package/Runtime/Internal/ReportSubmitResult.cs

@@ -0,0 +1,16 @@
+using LC.Newtonsoft.Json;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Report.Internal
+{
+    public class ReportSubmitResult : BaseResponse
+    {
+        [JsonProperty("data")]
+        public ReportSubmitBean ReportSubmitData;
+
+        public class ReportSubmitBean
+        {
+            [JsonProperty("success")] public bool Success { get; set; }
+        }
+    }
+}

package/Runtime/Internal/ReportSubmitResult.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cbad667fef1547d9a8cebb44ff733ff7
+timeCreated: 1715652010

package/Runtime/Internal/SignedUrlResponse.cs

@@ -0,0 +1,16 @@
+using LC.Newtonsoft.Json;
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Report.Internal
+{
+    public class SignedUrlResponse : BaseResponse
+    {
+        [JsonProperty("data")] public SignedUrlBean SignedUrlData { get; set; }
+
+        public class SignedUrlBean
+        {
+            [JsonProperty("signedUrl")] public string SignedUrl { get; set; }
+            [JsonProperty("timeOutSec")] public int TimeOutSec { get; set; }
+        }
+    }
+}

package/Runtime/Internal/SignedUrlResponse.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aded07794dfa4b669cc0c01c021014c3
+timeCreated: 1715649927

package/Runtime/Internal/UploadEvidenceResponse.cs

@@ -0,0 +1,9 @@
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Report.Internal
+{
+    public class UploadEvidenceResponse: BaseResponse
+    {
+        
+    }
+}

package/Runtime/Internal/UploadEvidenceResponse.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8d84456af1d34b96b1e37e7d3c0a6f5e
+timeCreated: 1715739257

package/Runtime/Internal.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 70c800d9be714ee682adff2e338f0194
+timeCreated: 1715590590

package/Runtime/Public/ReportParams.cs

@@ -0,0 +1,131 @@
+using System.Collections.Generic;
+
+namespace XD.SDK.Report
+{
+    public class ReportParams
+    {
+        public ReporterInfo Reporter { get; } // 举报人
+        public ReporteeInfo Reportee { get; } // 被举报人
+        public List<ReasonInfo> Reasons { get; } // 举报原因
+        public string UserDescription { get; } // 玩家描述
+        public List<string> EvidenceList { get; } // 玩家添加的附件
+        public Dictionary<string, object> Extras { get; } // 附加信息补充玩家信息，透传给使用方
+        
+
+        private ReportParams(ReporterInfo reporter, ReporteeInfo reportee, List<ReasonInfo> reasons, string userDescription, List<string> evidenceList, Dictionary<string, object> extras)
+        {
+            Reporter = reporter;
+            Reportee = reportee;
+            Reasons = reasons;
+            UserDescription = userDescription;
+            EvidenceList = evidenceList;
+            Extras = extras;
+        }
+
+        public class ReporterInfo
+        {
+            public Dictionary<string, object> Extras { get; }
+
+            public ReporterInfo(Dictionary<string, object> extras)
+            {
+                Extras = extras;
+            }
+
+            public override string ToString()
+            {
+                return $"ReporterInfo: Extras={string.Join(",", Extras)}";
+            }
+        }
+
+        public class ReporteeInfo
+        {
+            public string XdId { get; }
+            public Dictionary<string, object> Extras { get; }
+
+            public ReporteeInfo(string xdId, Dictionary<string, object> extras)
+            {
+                XdId = xdId;
+                Extras = extras;
+            }
+
+            public override string ToString()
+            {
+                return $"ReporteeInfo: XdId={XdId},  Extras={string.Join(",", Extras)}";
+            }
+        }
+
+        public class ReasonInfo
+        {
+            public long ID { get; } // 举报原因 ID，后台配置
+            public string Title { get; } // 原因名称
+            public Dictionary<string, object> Extras { get; } // 附加信息补充玩家信息，透传给使用方
+
+            public ReasonInfo(long id, string title, Dictionary<string, object> extras)
+            {
+                ID = id;
+                Title = title;
+                Extras = extras;
+            }
+
+            public override string ToString()
+            {
+                return $"ReasonInfo: ID={ID}, Title={Title}, Extras={string.Join(",", Extras)}";
+            }
+        }
+
+        public class Builder
+        {
+            private ReporterInfo _reporter;
+            private ReporteeInfo _reportee;
+            private List<ReasonInfo> _reasons;
+            private string _userDescription;
+            private List<string> _evidenceList;
+            private Dictionary<string, object> _extras;
+            public Builder SetReporter(ReporterInfo reporter)
+            {
+                _reporter = reporter;
+                return this;
+            }
+
+            public Builder SetReportee(ReporteeInfo reportee)
+            {
+                _reportee = reportee;
+                return this;
+            }
+
+            public Builder SetReasons(List<ReasonInfo> reasons)
+            {
+                _reasons = reasons;
+                return this;
+            }
+
+            public Builder SetUserDescription(string userDescription)
+            {
+                _userDescription = userDescription;
+                return this;
+            }
+
+            public Builder SetEvidenceList(List<string> evidenceList)
+            {
+                _evidenceList = evidenceList;
+                return this;
+            }
+
+            public Builder SetExtras(Dictionary<string, object> extras)
+            {
+                _extras = extras;
+                return this;
+            }
+
+            public ReportParams Build()
+            {
+                return new ReportParams(_reporter, _reportee, _reasons, _userDescription, _evidenceList, _extras);
+            }
+        }
+
+        public override string ToString()
+        {
+            return $"ReportParams: {Reporter}, {Reportee}, {Reasons}, UserDescription={UserDescription}, EvidenceList={string.Join(",", EvidenceList)}, Extras={string.Join(",", Extras)}";
+        }
+    }
+}

package/Runtime/Public/ReportParams.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 938fb21d03044ea38c0ecca51e84da87
+timeCreated: 1715652473

package/Runtime/Public/ReportResult.cs

@@ -0,0 +1,24 @@
+using XD.SDK.Common.Internal;
+
+namespace XD.SDK.Report
+{
+    public class ReportResult
+    {
+        public const int CodeParamInvalid = -1; // 无效参数
+        public const int CodeUserNotLoggedIn = -2; // 用户未登录
+        public const int CodeFileNotExist = -3; // 文件不存在
+        public bool Success { get; }
+        public XDException XdException { get; }
+
+        public ReportResult(bool success, XDException exception)
+        {
+            Success = success;
+            XdException = exception;
+        }
+
+        public override string ToString()
+        {
+            return $"ReportResult: Success={Success} XdException={XdException}";
+        }
+    }
+}

package/Runtime/Public/ReportResult.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0162e2273cd1465990acdb00e76979ce
+timeCreated: 1716186590

package/Runtime/Public/XDGReport.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace XD.SDK.Report
+{
+    public class XDGReport
+    {
+        public static void Report(ReportParams reportParams, Action<ReportResult> resultCallback)
+        {
+            XDReportImpl.GetInstance().Report(reportParams, resultCallback);
+        }
+    }
+}

package/Runtime/Public/XDGReport.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a22be58d53464c9ea695c10e9a015a7e
+timeCreated: 1715590796

package/Runtime/Public/XDReportImpl.cs

@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using LC.Newtonsoft.Json;
+using XD.SDK.Account;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Report.Internal;
+using XDException = XD.SDK.Common.Internal.XDException;
+
+namespace XD.SDK.Report
+{
+    public class XDReportImpl
+    {
+        private const string ReportEndpoint = "reporting/v1/player/report";
+        private const string GetSignedUrlEndpoint = "reporting/v1/upload/oss_sign_url";
+        private const int DefaultTimeoutSec = 5 * 60;
+
+        private static volatile XDReportImpl _instance;
+        private static readonly object Locker = new object();
+
+        private XDReportImpl()
+        {
+        }
+
+        public static XDReportImpl GetInstance()
+        {
+            if (_instance != null) return _instance;
+            lock (Locker)
+            {
+                if (_instance == null)
+                {
+                    _instance = new XDReportImpl();
+                }
+            }
+
+            return _instance;
+        }
+
+        public void Report(ReportParams reportParams, Action<ReportResult> resultCallback)
+        {
+            var currentUserId = UserManager.GetCurrentUser()?.userId;
+            if (string.IsNullOrEmpty(currentUserId))
+            {
+                resultCallback.Invoke(new ReportResult(false,
+                    new XDException(ReportResult.CodeUserNotLoggedIn, "user is null, please login first!")));
+                return;
+            }
+            if (reportParams.Reportee == null || reportParams.Reportee.XdId.Length <= 0
+                                              || reportParams.Reasons == null || reportParams.Reasons.Count <= 0)
+            {
+                resultCallback.Invoke(new ReportResult(false,
+                    new XDException(ReportResult.CodeParamInvalid, "invalid report params , please check.")));
+                return;
+            }
+
+            ReportAsync(currentUserId, reportParams, resultCallback).ConfigureAwait(false);
+        }
+
+        private static async Task ReportAsync(string currentUserId, ReportParams reportParams, Action<ReportResult> resultCallback)
+        {
+            var requestParams = new ReportParamsInternal
+            {
+                Reporter = new ReportParamsInternal.UserInfo(currentUserId,
+                    reportParams.Reporter?.Extras == null
+                        ? null
+                        : JsonConvert.SerializeObject(reportParams.Reporter.Extras)),
+                Reportee = new ReportParamsInternal.UserInfo(reportParams.Reportee.XdId,
+                    reportParams.Reportee.Extras == null
+                        ? null
+                        : JsonConvert.SerializeObject(reportParams.Reportee.Extras)),
+                ReasonParams = reportParams.Reasons.Select((reasonInfo) => new ReportParamsInternal.ReasonParam
+                {
+                    ID = reasonInfo.ID,
+                    Title = reasonInfo.Title,
+                    Extras = reasonInfo.Extras == null ? null : JsonConvert.SerializeObject(reasonInfo.Extras)
+                }).ToList(),
+                UserDescription = reportParams.UserDescription,
+                Extras = reportParams.Extras == null ? null : JsonConvert.SerializeObject(reportParams.Extras)
+            };
+
+            var cts = new CancellationTokenSource();
+            var token = CancellationTokenSource.CreateLinkedTokenSource(cts.Token).Token;
+
+            if (reportParams.EvidenceList != null && reportParams.EvidenceList.Count > 0)
+            {
+                try
+                {
+                    var uploadEvidenceTasks = reportParams.EvidenceList
+                        .Select(filePath => UploadEvidence(filePath, cts, token))
+                        .ToList();
+
+                    var results = await Task.WhenAll(uploadEvidenceTasks);
+                    var evidenceList = results.ToList();
+
+                    requestParams.Evidence = evidenceList;
+                }
+                catch (XDException ex)
+                {
+                    XDGLogger.Error("Report failed, upload evidence error:" + ex);
+                    cts.Cancel();
+                    resultCallback.Invoke(new ReportResult(false, ex));
+                    return;
+                }
+                catch (OperationCanceledException ex)
+                {
+                    XDGLogger.Warn("upload evidence canceled:" + ex.Message);
+                    return;
+                }
+                catch (Exception e)
+                {
+                    XDGLogger.Error("Report failed, upload evidence Unexpected exception:" + e.Message);
+                    cts.Cancel();
+                    resultCallback.Invoke(new ReportResult(false,
+                        new XDException(XDException.DEFAULT_CODE, e.Message)));
+                    return;
+                }
+            }
+
+            try
+            {
+                var reportSubmitResult = await XDHttpClientFactory.GetDefaultXdHttpClient()
+                    .Post<ReportSubmitResult>(ReportEndpoint, data: requestParams);
+                resultCallback.Invoke(new ReportResult(reportSubmitResult.ReportSubmitData.Success,
+                    new XDException(reportSubmitResult.Code, reportSubmitResult.Message)));
+            }
+            catch (XDException e)
+            {
+                XDGLogger.Error("Report failed: " + e);
+                resultCallback.Invoke(new ReportResult(false, e));
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error("Report failed: Unexpected exception:" + e.Message);
+                resultCallback.Invoke(new ReportResult(false, new XDException(XDException.DEFAULT_CODE, e.Message)));
+            }
+        }
+
+        private static async Task<EvidenceInfo> UploadEvidence(string filePath,
+            CancellationTokenSource cancellationTokenSource, CancellationToken token)
+        {
+            if (!File.Exists(filePath))
+            {
+                XDGLogger.Error($"report failed, file: {filePath} dose not exist");
+                throw new XDException(ReportResult.CodeFileNotExist, $"file: {filePath} does not exist");
+            }
+
+            var fileInfo = new FileInfo(filePath);
+            var queryParams = new Dictionary<string, object>
+            {
+                ["file_name"] = fileInfo.Name,
+                ["file_size"] = fileInfo.Length
+            };
+
+            SignedUrlResponse signedUrlResponse;
+            try
+            {
+                signedUrlResponse = await XDHttpClientFactory.GetDefaultXdHttpClient()
+                    .Get<SignedUrlResponse>(GetSignedUrlEndpoint, queryParams: queryParams);
+            }
+            catch (OperationCanceledException ex)
+            {
+                XDGLogger.Warn("UploadEvidenceBySignedOssUrl upload evidence canceled:" + ex.Message);
+                throw;
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error("Get Signed Url error: " + e);
+                cancellationTokenSource.Cancel();
+                throw;
+            }
+            
+            var fullUrl = signedUrlResponse?.SignedUrlData?.SignedUrl;
+            if (string.IsNullOrEmpty(fullUrl))
+            {
+                XDGLogger.Error("upload evidence error: couldn't get signed url.");
+                cancellationTokenSource.Cancel();
+                throw new XDException(XDException.DEFAULT_CODE, "Couldn't get signed url");
+            }
+
+            try
+            {
+                var timeOutSec = signedUrlResponse.SignedUrlData.TimeOutSec;
+                if (timeOutSec <= 0)
+                {
+                    timeOutSec = DefaultTimeoutSec;
+                }
+
+                var uploadEvidenceResponse =
+                    await UploadEvidenceBySignedOssUrl(signedUrlResponse.SignedUrlData.SignedUrl, timeOutSec,
+                        filePath, token);
+                if (uploadEvidenceResponse.StatusCode == HttpStatusCode.OK)
+                {
+                    var uri = new Uri(fullUrl);
+                    var evidenceInfo = new EvidenceInfo(fileInfo.Name,
+                        new Uri(uri.GetLeftPart(UriPartial.Path)).ToString(), fileInfo.Length);
+                    return evidenceInfo;
+                }
+
+                var errorContent = await uploadEvidenceResponse.Content.ReadAsStringAsync();
+                var ex = new XDException((int)uploadEvidenceResponse.StatusCode, errorContent);
+                XDGLogger.Error("Report upload evidences failed: " + ex);
+                throw ex;
+            }
+            catch (OperationCanceledException ex)
+            {
+                XDGLogger.Warn("UploadEvidence upload evidence canceled:" + ex.Message);
+                throw;
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Error("Report upload evidences catch an error: " + e);
+                cancellationTokenSource.Cancel();
+                throw;
+            }
+        }
+
+        private static async Task<HttpResponseMessage> UploadEvidenceBySignedOssUrl(string signedOssUrl, int timeOutSec,
+            string filePath, CancellationToken token)
+        {
+            using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
+            {
+                try
+                {
+                    var content = new StreamContent(fileStream);
+                    var ossClient = new HttpClient(new XdDelegatingHandler(new HttpClientHandler()));
+                    ossClient.Timeout = TimeSpan.FromSeconds(timeOutSec);
+                    var response = await ossClient.PutAsync($"{signedOssUrl}", content, token);
+                    return response;
+                }
+                catch (OperationCanceledException ex)
+                {
+                    XDGLogger.Warn("UploadEvidenceBySignedOssUrl upload evidence canceled:" + ex);
+                    if (!token.IsCancellationRequested)
+                    {
+                        throw new TimeoutException("UploadEvidenceBySignedOssUrl upload evidence timeout");    
+                    }
+
+                    throw;
+                }
+                catch (Exception e)
+                {
+                    XDGLogger.Error("signedOssUrl: " + signedOssUrl + ", ------> " + e);
+                    throw;
+                }
+            }
+        }
+    }
+}

package/Runtime/Public/XDReportImpl.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e7861bf22d7b447ba07dbe03870edbd3
+timeCreated: 1715592452

package/Runtime/Public.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 75fec9f95a0645f8af57bd8228b3df0f
+timeCreated: 1715590596

package/Runtime/XD.SDK.Report.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "XD.SDK.Report",
+    "rootNamespace": "",
+    "references": [
+        "GUID:271a06ab0780d4a5ea46c9c3be2ab5dc",
+        "GUID:8b2e8a99ce9ab457da469f8744959bc2",
+        "GUID:c72576b1c89c54ea0a0d748ee92b35c2"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/XD.SDK.Report.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: df292eb1ae1fe42fb908e90459182fd1
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 861f533b37904f6ba0281f90334240e5
+timeCreated: 1715590568

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "com.xd.sdk.report",
+  "version": "0.0.1",
+  "description": "XDSDK",
+  "unity": "2018.3",
+  "license": "MIT",
+  "dependencies": {
+    "com.xd.sdk.common": "0.0.1",
+    "com.xd.tds.common": "3.27.1-xd.1"
+  }
+}

package/package.json.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9085c62777ce4df387fa9add5c2f8ac1
+timeCreated: 1716287109