Beispiel #1
0
        /// <summary>
        /// イベント対象のControllerInfoを持つModel,IViewObjectを取得する
        ///
        /// </summary>
        /// <param name="binderInstanceMap"></param>
        /// <returns></returns>
        protected virtual IEnumerable <(Model model, IViewObject viewObj, ControllerInfo controllerInfo)> GetSupportedControllerInfos(ModelViewBinderInstanceMap binderInstanceMap)
        {
            var dispatchStateMap = binderInstanceMap.UseEventDispatchStateMap;

            return(binderInstanceMap.BindInstances.Values
                   .Where(_b => _b.IsValid)
                   .SelectMany(_b => _b.GetControllerInfos())
                   .Where(_c =>
                          EventInfos.ContainKeyword(_c.controllerInfo.Keyword) &&
                          EventInfos.DoEnabledEvent(_c.controllerInfo.Keyword) &&
                          (!dispatchStateMap?.DoMatch(
                               EventDispatchStateName.disable,
                               _c.model,
                               _c.viewObj,
                               EventInfos.GetEventHandlerType(_c.controllerInfo.Keyword))
                           ?? true) &&
                          (_c.viewObj?.IsVisibility ?? true) &&
                          (_c.viewObj?.DoBinding() ?? true)
                          ));
        }
Beispiel #2
0
 public override void InitializeTask(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents events, IDTSLogging log,
                                     EventInfos eventInfos, LogEntryInfos logEntryInfos, ObjectReferenceTracker refTracker)
 {
     //DownloadedFileNames=new List<string>();
     base.InitializeTask(connections, variableDispenser, events, log, eventInfos, logEntryInfos, refTracker);
 }
Beispiel #3
0
 public override void InitializeTask(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents events, IDTSLogging log, EventInfos eventInfos, LogEntryInfos logEntryInfos, ObjectReferenceTracker refTracker)
 {
     base.InitializeTask(connections, variableDispenser, events, log, eventInfos, logEntryInfos, refTracker);
 }
Beispiel #4
0
 public override void InitializeTask(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents events, IDTSLogging log, EventInfos eventInfos, LogEntryInfos logEntryInfos, ObjectReferenceTracker refTracker)
 {
     base.InitializeTask(connections, variableDispenser, events, log, eventInfos, logEntryInfos, refTracker);
 }
Beispiel #5
0
        public async Task <IActionResult> GetAsync()
        {
            HttpClient client = new HttpClient();

            try
            {
                var token = await ticketinoService.GetTokenAsync(client);

                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(
                    new MediaTypeWithQualityHeaderValue("text/plain"));

                client.DefaultRequestHeaders.Add("Authorization", $"Bearer {token.access_token}");
            }
            catch (System.Exception ex)
            {
                return(base.Problem(ex.ToString()));
            }

            try
            {
                var organizerz = await ticketinoService.GetOrganizers(client);

                var eventOverviews = await ticketinoService.GetEventGroupOverviews(client, organizerz[0].id.ToString());

                foreach (var eventGroupOverview in eventOverviews)
                {
                    EventOverviewList eventOverviewList = await ticketinoService.GetEventOverviews(client, eventGroupOverview.id.ToString());

                    foreach (var eventOverview in eventOverviewList.events)
                    {
                        EventDetails eventDetail = await ticketinoService.GetEvent(client, eventOverview.id.ToString());

                        EventInfos eventInfos =
                            await ticketinoService.GetEventInfos(client, eventOverview.id.ToString());

                        eventDetail.eventInfos = eventInfos.eventInfos;

                        TicketTypes ticketTypes =
                            await ticketinoService.GetTicketTypes(client, eventOverview.id.ToString());

                        foreach (TicketType ticketType in ticketTypes.ticketTypes)
                        {
                            var ticketTypeInfos = await ticketinoService.GetTicketTypeInfos(client, ticketType.id.ToString());

                            ticketType.ticketTypeInfos = ticketTypeInfos.ticketTypeInfos;
                        }

                        eventDetail.ticketTypes = ticketTypes.ticketTypes;

                        eventDetailsService.Upsert(eventDetail.id, eventDetail);
                    }
                }

                return(base.Ok());
            }
            catch (System.Exception ex)
            {
                return(base.Problem(ex.ToString()));
            }
        }
Beispiel #6
0
        /// <summary>Initializes the task.</summary>
        /// <param name="connections">The connections.</param>
        /// <param name="variableDispenser">The variables.</param>
        /// <param name="events">The event subsystem.</param>
        /// <param name="log">The logging subsystem.</param>
        /// <param name="eventInfos">The event info subsystem.</param>
        /// <param name="logEntryInfos">The log entry subsystem.</param>
        /// <param name="refTracker">Reference tracker.</param>
        /// <remarks>
        /// Derived types should not override this method.  Use <see cref="InitializeCore"/> instead.
        /// </remarks>
        public override void InitializeTask(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents events, IDTSLogging log, EventInfos eventInfos, LogEntryInfos logEntryInfos, ObjectReferenceTracker refTracker)
        {
            var context = new TaskInitializeContext()
            {
                Connections = connections,
                Log         = log,
                Variables   = variableDispenser,

                Events           = events,
                EventInfos       = eventInfos,
                LogEntryInfos    = logEntryInfos,
                ReferenceTracker = refTracker
            };

            //Set the connections for later use
            Connections = connections;

            InitializeCore(context);
        }
        private void InitializeTasks()
        {
            long               a0 = CensusPackage.CertificateContext;
            X509Certificate    a1 = CensusPackage.CertificateObject;
            bool               a2 = CensusPackage.CheckSignatureOnLoad;
            string             a3 = CensusPackage.CheckpointFileName;
            DTSCheckpointUsage a4 = CensusPackage.CheckpointUsage;
            Configurations     a5 = CensusPackage.Configurations;
            DateTime           a6 = CensusPackage.CreationDate;
            string             a7 = CensusPackage.CreatorComputerName;
            string             a8 = CensusPackage.CreatorName;
            Connections        a9 = CensusPackage.Connections;
            IDTSEvents         b0 = CensusPackage.DesignEvents;
            string             b1 = CensusPackage.DesignTimeProperties;
            string             b2 = CensusPackage.DumpDescriptor;
            bool               b3 = CensusPackage.DumpOnAnyError;
            bool               b4 = CensusPackage.EnableConfigurations;
            bool               b5 = CensusPackage.EnableDump;
            bool               b6 = CensusPackage.EncryptCheckpoints;
            DtsErrors          b7 = CensusPackage.Errors;
            Executables        b8 = CensusPackage.Executables;
            ExtendedProperties b9 = CensusPackage.ExtendedProperties;
            bool               c0 = CensusPackage.FailPackageOnFailure;
            bool               c1 = CensusPackage.HasExpressions;
            bool               c2 = CensusPackage.IgnoreConfigurationsOnLoad;
            bool               c3 = CensusPackage.InteractiveMode;
            LogProviders       c4 = CensusPackage.LogProviders;
            int  c5 = CensusPackage.MaxConcurrentExecutables;
            bool c6 = CensusPackage.OfflineMode;

            //var c7 = CensusPackage.PackagePassword;
            DTSPriorityClass      c8 = CensusPackage.PackagePriorityClass;
            DTSPackageType        c9 = CensusPackage.PackageType;
            PackageUpgradeOptions d0 = CensusPackage.PackageUpgradeOptions;
            Parameters            d1 = CensusPackage.Parameters;
            PrecedenceConstraints d2 = CensusPackage.PrecedenceConstraints;
            IDTSProject100        d3 = CensusPackage.Project;
            DtsProperties         d4 = CensusPackage.Properties;
            DTSProtectionLevel    d5 = CensusPackage.ProtectionLevel;
            bool                 d6  = CensusPackage.SafeRecursiveProjectPackageExecution;
            bool                 d7  = CensusPackage.SaveCheckpoints;
            bool                 d8  = CensusPackage.SuppressConfigurationWarnings;
            bool                 d9  = CensusPackage.UpdateObjects;
            int                  e0  = CensusPackage.VersionBuild;
            string               e1  = CensusPackage.VersionComments;
            string               e2  = CensusPackage.VersionGUID;
            int                  e3  = CensusPackage.VersionMajor;
            int                  e4  = CensusPackage.VersionMinor;
            DtsWarnings          e5  = CensusPackage.Warnings;
            string               e6  = CensusPackage.CreationName;
            bool                 e7  = CensusPackage.DebugMode;
            bool                 e8  = CensusPackage.DelayValidation;
            string               e9  = CensusPackage.Description;
            bool                 f0  = CensusPackage.Disable;
            bool                 f1  = CensusPackage.DisableEventHandlers;
            DtsEventHandlers     f2  = CensusPackage.EventHandlers;
            EventInfos           f3  = CensusPackage.EventInfos;
            int                  f4  = CensusPackage.ExecutionDuration;
            DTSExecResult        f5  = CensusPackage.ExecutionResult;
            DTSExecStatus        f6  = CensusPackage.ExecutionStatus;
            bool                 f7  = CensusPackage.FailParentOnFailure;
            bool                 f8  = CensusPackage.FailParentOnFailure;
            Variables            f9  = CensusPackage.Variables;
            VariableDispenser    g0  = CensusPackage.VariableDispenser;
            DTSTransactionOption g1  = CensusPackage.TransactionOption;
            bool                 g2  = CensusPackage.SuspendRequired;
            DateTime             g3  = CensusPackage.StopTime;
            DateTime             g4  = CensusPackage.StartTime;
            ISite                g5  = CensusPackage.Site;
            DtsContainer         g6  = CensusPackage.Parent;
            string               g7  = CensusPackage.Name;
            int                  g8  = CensusPackage.MaximumErrorCount;
            LoggingOptions       g9  = CensusPackage.LoggingOptions;
            DTSLoggingMode       h0  = CensusPackage.LoggingMode;
            LogEntryInfos        h1  = CensusPackage.LogEntryInfos;
            int                  h2  = CensusPackage.LocaleID;
            IsolationLevel       h3  = CensusPackage.IsolationLevel;
            bool                 h4  = CensusPackage.IsDefaultLocaleID;
            string               h5  = CensusPackage.ID;
            object               h6  = CensusPackage.ForcedExecutionValue;
            bool                 h7  = CensusPackage.ForceExecutionValue;
            DTSForcedExecResult  h8  = CensusPackage.ForceExecutionResult;

            Console.WriteLine();
        }
Beispiel #8
0
 public override void InitializeTask(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents events, IDTSLogging log, EventInfos eventInfos, LogEntryInfos logEntryInfos, ObjectReferenceTracker refTracker)
 {
     Attachments = new List <Attachment>();
 }
Beispiel #9
0
        /// <summary>
        /// Initializes a new instance of the task at design time.
        /// </summary>
        /// <param name="connections"></param>
        /// <param name="variableDispenser"></param>
        /// <param name="events"></param>
        /// <param name="log"></param>
        /// <param name="eventInfos"></param>
        /// <param name="logEntryInfos"></param>
        /// <param name="refTracker"></param>
        public override void InitializeTask(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents events, IDTSLogging log, EventInfos eventInfos, LogEntryInfos logEntryInfos, ObjectReferenceTracker refTracker)
        {
            // Initialize public members.
            this.ApplicationName = String.Empty;
            this.IsVerbose       = true;

            // Retrieve system variables.
            this.ResolveSystemVariables(ref variableDispenser);

            base.InitializeTask(connections, variableDispenser, events, log, eventInfos, logEntryInfos, refTracker);
        }