connected-spaces-platform.unity.core 4.10.0-prerelease3

package/Source/Systems/EventTicketing/EventTicketingSystem.cs

@@ -0,0 +1,563 @@
+// WARNING: DO NOT EDIT THIS FILE! IT IS A GENERATED FILE AND
+//   ANY CHANGES YOU MAKE WILL BE OVERWRITTEN ON THE NEXT BUILD
+
+#nullable enable annotations
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Threading.Tasks;
+
+namespace Csp.Systems
+{
+    /// @ingroup Event Ticketing System
+    /// <summary>System that allows creation and management of ticketed events for spaces.</summary>
+
+    public class EventTicketingSystem : Csp.Systems.SystemBase
+    {
+        internal override string _safeTypeName { get; } = "csp_systems_EventTicketingSystem";
+
+        #region P/Invoke
+#pragma warning disable IDE1006
+
+
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_EventTicketingSystem_Dtor(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_EventTicketingSystem_CreateTicketedEvent_void_StringRC_EventTicketingVendor_StringRC_StringRC_bool_TicketedEventResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            EventTicketingVendor Vendor,
+            string VendorEventId,
+            string VendorEventUri,
+            bool IsTicketingActive,
+            CreateTicketedEventCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_EventTicketingSystem_UpdateTicketedEvent_void_StringRC_StringRC_EventTicketingVendor_StringRC_StringRC_bool_TicketedEventResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            string EventId,
+            EventTicketingVendor Vendor,
+            string VendorEventId,
+            string VendorEventUri,
+            bool IsTicketingActive,
+            UpdateTicketedEventCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_EventTicketingSystem_GetTicketedEvents_void_ArrayRC_intRC_intRC_TicketedEventCollectionResultCallback(
+            IntPtr @class,
+            IntPtr SpaceIds,
+            IntPtr Skip,
+            IntPtr Limit,
+            GetTicketedEventsCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_EventTicketingSystem_SubmitEventTicket_void_StringRC_EventTicketingVendor_StringRC_StringRC_StringRC_EventTicketResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            EventTicketingVendor Vendor,
+            string VendorEventId,
+            string VendorTicketId,
+            string OnBehalfOfUserId,
+            SubmitEventTicketCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_EventTicketingSystem_GetVendorAuthorizeInfo_void_EventTicketingVendor_StringRC_TicketedEventVendorAuthorizeInfoCallback(
+            IntPtr @class,
+            EventTicketingVendor Vendor,
+            string UserId,
+            GetVendorAuthorizeInfoCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_EventTicketingSystem_GetIsSpaceTicketed_void_StringRC_SpaceIsTicketedResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetIsSpaceTicketedCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern NativePointer csp_systems_EventTicketingSystem_Ctor();
+
+#pragma warning restore IDE1006
+        #endregion
+
+        internal EventTicketingSystem(NativePointer ptr) : base(ptr) { }
+
+        public EventTicketingSystem(Csp.Systems.SystemBase baseInstance)
+            : base(new NativePointer(baseInstance._ptr, baseInstance._ownsPtr ? (byte)1 : (byte)0))
+        {
+            // Prevent previous instance from freeing underlying pointer when destroyed
+            baseInstance._ownsPtr = false;
+        }
+
+        delegate void CreateTicketedEventCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateTicketedEventCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetTicketedEventsCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void SubmitEventTicketCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetVendorAuthorizeInfoCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetIsSpaceTicketedCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        ~EventTicketingSystem()
+        {
+            //RealDispose();
+        }
+
+        void RealDispose()
+        {
+            if (_ownsPtr && !_disposed)
+            {
+                csp_systems_EventTicketingSystem_Dtor(_ptr);
+                _disposed = true;
+            }
+
+            _disposed = true;
+        }
+
+        new public void Dispose()
+        {
+            RealDispose();
+            GC.SuppressFinalize(this);
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (CreateTicketedEventCallbackDelegate))]
+#endif
+        static void CreateTicketedEventCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.TicketedEventResult>)_handle.Target;
+            var _this = (EventTicketingSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.TicketedEventResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly CreateTicketedEventCallbackDelegate CreateTicketedEventDelegateInstance =
+            CreateTicketedEventCallbackDelegateFunction;
+
+        /// <summary>Creates a ticketed event for the given space.</summary>
+                /// <param name="SpaceId">ID of the space to create the event for.</param>
+                /// <param name="Vendor">Enum representing the vendor that the event is created with.</param>
+                /// <param name="VendorEventId">Specifies the event ID in the vendors system.</param>
+                /// <param name="VendorEventUri">Specifies the URI for the event in the vendors system.</param>
+                /// <param name="IsTicketingActive">Specifies whether ticketing is currently active for this event.</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.TicketedEventResult> CreateTicketedEvent(
+            string SpaceId,
+            Csp.Systems.EventTicketingVendor Vendor,
+            string VendorEventId,
+            string VendorEventUri,
+            bool IsTicketingActive
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.TicketedEventResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_EventTicketingSystem_CreateTicketedEvent_void_StringRC_EventTicketingVendor_StringRC_StringRC_bool_TicketedEventResultCallback(
+                _ptr,
+                SpaceId,
+                Vendor,
+                VendorEventId,
+                VendorEventUri,
+                IsTicketingActive,
+                CreateTicketedEventDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateTicketedEventCallbackDelegate))]
+#endif
+        static void UpdateTicketedEventCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.TicketedEventResult>)_handle.Target;
+            var _this = (EventTicketingSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.TicketedEventResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly UpdateTicketedEventCallbackDelegate UpdateTicketedEventDelegateInstance =
+            UpdateTicketedEventCallbackDelegateFunction;
+
+        /// <summary>Updates a ticketed event in the given space.</summary>
+                /// <remarks>/// All parameters should be provided even if they are not new values. Empty values will overwrite</remarks>
+                /// <remarks>existing values to be empty.</remarks>
+                /// <remarks>/// @param SpaceId csp::common::String : ID of the space the event belongs to.</remarks>
+                /// <param name="EventId">ID of the Event to update.</param>
+                /// <param name="Vendor">Enum representing the vendor that the event is created with.</param>
+                /// <param name="VendorEventId">Specifies the event ID in the vendors system.</param>
+                /// <param name="VendorEventUri">Specifies the URI for the event in the vendors system.</param>
+                /// <param name="IsTicketingActive">Specifies whether ticketing is currently active for this event.</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.TicketedEventResult> UpdateTicketedEvent(
+            string SpaceId,
+            string EventId,
+            Csp.Systems.EventTicketingVendor Vendor,
+            string VendorEventId,
+            string VendorEventUri,
+            bool IsTicketingActive
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.TicketedEventResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_EventTicketingSystem_UpdateTicketedEvent_void_StringRC_StringRC_EventTicketingVendor_StringRC_StringRC_bool_TicketedEventResultCallback(
+                _ptr,
+                SpaceId,
+                EventId,
+                Vendor,
+                VendorEventId,
+                VendorEventUri,
+                IsTicketingActive,
+                UpdateTicketedEventDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetTicketedEventsCallbackDelegate))]
+#endif
+        static void GetTicketedEventsCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.TicketedEventCollectionResult>)_handle.Target;
+            var _this = (EventTicketingSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.TicketedEventCollectionResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetTicketedEventsCallbackDelegate GetTicketedEventsDelegateInstance =
+            GetTicketedEventsCallbackDelegateFunction;
+
+        /// <summary>Creates a ticketed event for the given space.</summary>
+                /// <param name="SpaceIds">IDs of the spaces to get the events for.</param>
+                /// <param name="Skip">Optional number of results that will be skipped from the result.</param>
+                /// <param name="Limit">Optional maximum number of results to be retrieved.</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.TicketedEventCollectionResult> GetTicketedEvents(
+            Csp.Common.Array<string> SpaceIds,
+            int? Skip,
+            int? Limit
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.TicketedEventCollectionResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            var SkipPointer = IntPtr.Zero;
+            unsafe
+            {
+                if (Skip.HasValue)
+                {
+                    var ptr = stackalloc int[1];
+                    *ptr = Skip.Value;
+                    SkipPointer = (IntPtr)ptr;
+                }
+            }
+            var LimitPointer = IntPtr.Zero;
+            unsafe
+            {
+                if (Limit.HasValue)
+                {
+                    var ptr = stackalloc int[1];
+                    *ptr = Limit.Value;
+                    LimitPointer = (IntPtr)ptr;
+                }
+            }
+
+            csp_systems_EventTicketingSystem_GetTicketedEvents_void_ArrayRC_intRC_intRC_TicketedEventCollectionResultCallback(
+                _ptr,
+                SpaceIds._ptr,
+                SkipPointer,
+                LimitPointer,
+                GetTicketedEventsDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (SubmitEventTicketCallbackDelegate))]
+#endif
+        static void SubmitEventTicketCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.EventTicketResult>)_handle.Target;
+            var _this = (EventTicketingSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.EventTicketResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly SubmitEventTicketCallbackDelegate SubmitEventTicketDelegateInstance =
+            SubmitEventTicketCallbackDelegateFunction;
+
+        /// <summary>Submits a ticket from a vendor for the given event.</summary>
+                /// <remarks>/// @param SpaceId csp::common::String : ID of the space the event belongs to.</remarks>
+                /// <param name="Vendor">Enum representing the vendor that the event is created with.</param>
+                /// <param name="VendorEventId">Specifies the event ID in the vendors system.</param>
+                /// <param name="VendorTicketId">Specifies the ticket ID in the vendors system.</param>
+                /// <param name="OnBehalfOfUserId">Optionally submit the ticket for another user. Requires super user</param>
+                /// <remarks>permissions.</remarks>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.EventTicketResult> SubmitEventTicket(
+            string SpaceId,
+            Csp.Systems.EventTicketingVendor Vendor,
+            string VendorEventId,
+            string VendorTicketId,
+            string? OnBehalfOfUserId
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.EventTicketResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_EventTicketingSystem_SubmitEventTicket_void_StringRC_EventTicketingVendor_StringRC_StringRC_StringRC_EventTicketResultCallback(
+                _ptr,
+                SpaceId,
+                Vendor,
+                VendorEventId,
+                VendorTicketId,
+                OnBehalfOfUserId,
+                SubmitEventTicketDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetVendorAuthorizeInfoCallbackDelegate))]
+#endif
+        static void GetVendorAuthorizeInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.TicketedEventVendorAuthInfoResult>)_handle.Target;
+            var _this = (EventTicketingSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.TicketedEventVendorAuthInfoResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetVendorAuthorizeInfoCallbackDelegate GetVendorAuthorizeInfoDelegateInstance =
+            GetVendorAuthorizeInfoCallbackDelegateFunction;
+
+        /// <summary> Looks up the basic info required by a client to initiate an oauth2 flow with the specified vendor.</summary>
+                /// <param name="Vendor">The vendor type to retrieve info for.</param>
+                /// <param name="UserId">The ID of the user to obtain authentication info for.</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.TicketedEventVendorAuthInfoResult> GetVendorAuthorizeInfo(
+            Csp.Systems.EventTicketingVendor Vendor,
+            string UserId
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.TicketedEventVendorAuthInfoResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_EventTicketingSystem_GetVendorAuthorizeInfo_void_EventTicketingVendor_StringRC_TicketedEventVendorAuthorizeInfoCallback(
+                _ptr,
+                Vendor,
+                UserId,
+                GetVendorAuthorizeInfoDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetIsSpaceTicketedCallbackDelegate))]
+#endif
+        static void GetIsSpaceTicketedCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpaceIsTicketedResult>)_handle.Target;
+            var _this = (EventTicketingSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpaceIsTicketedResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetIsSpaceTicketedCallbackDelegate GetIsSpaceTicketedDelegateInstance =
+            GetIsSpaceTicketedCallbackDelegateFunction;
+
+        /// <summary>Gets the ticketed status of a space given by ID.</summary>
+                /// <param name="SpaceId">The space ID to check the status for.</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpaceIsTicketedResult> GetIsSpaceTicketed(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpaceIsTicketedResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_EventTicketingSystem_GetIsSpaceTicketed_void_StringRC_SpaceIsTicketedResultCallback(
+                _ptr,
+                SpaceId,
+                GetIsSpaceTicketedDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+        protected EventTicketingSystem() { }
+    }
+}
+

package/Source/Systems/EventTicketing/EventTicketingSystem.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2a6db4eb5f104210bbb45ef493bfac02
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: null
+  assetBundleName: null
+  assetBundleVariant: null

package/Source/Systems/EventTicketing/EventTicketingVendor.cs

@@ -0,0 +1,24 @@
+// WARNING: DO NOT EDIT THIS FILE! IT IS A GENERATED FILE AND
+//   ANY CHANGES YOU MAKE WILL BE OVERWRITTEN ON THE NEXT BUILD
+
+#nullable enable annotations
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Threading.Tasks;
+
+namespace Csp.Systems
+{
+    /// @ingroup Event Ticketing System
+    /// <summary>Enum representing the third party vendor used for ticketing.</summary>
+
+    public enum EventTicketingVendor
+    {
+        Eventbrite = 0,
+        Unknown,
+    }
+}
+

package/Source/Systems/EventTicketing/EventTicketingVendor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c86dc784c2f3496da31a7c3618568b79
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: null
+  assetBundleName: null
+  assetBundleVariant: null