Exemple #1
0
        public MovilizerResponse PostRequest(MovilizerRequest request)
        {
            MovilizerResponse response = null;
            int countdown = 3;

            while (response == null && countdown > 0)
            {
                try
                {
                    countdown--;
                    response = Movilizer(request);
                }
                catch (Exception e)
                {
                    LogFactory.WriteError(e.ToString());

                    if (countdown > 0)
                    {
                        // sleep for 10 seconds and try again
                        Thread.Sleep(10000);
                    }
                    else
                    {
                        throw;
                    }
                }
            }

            return(response);
        }
 /// <remarks/>
 public void MovilizerAsync(MovilizerRequest MovilizerRequest, object userState) {
     if ((this.MovilizerOperationCompleted == null)) {
         this.MovilizerOperationCompleted = new System.Threading.SendOrPostCallback(this.OnMovilizerOperationCompleted);
     }
     this.InvokeAsync("Movilizer", new object[] {
                 MovilizerRequest}, this.MovilizerOperationCompleted, userState);
 }
        private void InitializeMoveletRequest(MovilizerRequest request)
        {
            request.systemId       = Configuration.GetSystemId();
            request.systemPassword = Configuration.GetSystemPassword();

            // send acknowlegement key
            request.requestAcknowledgeKey = _requestAckKey;
        }
Exemple #4
0
        private MovilizerRequest TreatRequest()
        {
            ConfigureWebServiceForRequest();

            // create request object
            MovilizerRequest request = this.ComposeRequest();

            request.numResponses = 1000;

            string debugOutput = Configuration.GetDebugOutputPath();

            if (!String.IsNullOrEmpty(debugOutput))
            {
                XmlHelper.SerializeToFile(debugOutput + "MovilizerRequest.xml", request);
            }
            return(request);
        }
        protected MovilizerRequest ComposeRequest()
        {
            // process outbound pools
            ProcessOutboundPool(_masterdataPoolUpdateTemplates);
            ProcessOutboundPool(_documentPoolUpdateTemplates);

            // process outbound queue
            ProcessOutboundQueue(_outQueue);

            // create request
            MovilizerRequest request = new MovilizerRequest();

            InitializeMoveletRequest(request);

            // assign parameters
            request.moveletSet               = _moveletSets.ToArray();
            request.moveletAssignment        = _moveletAssignments.ToArray();
            request.moveletDelete            = _moveletDeletes.ToArray();
            request.masterdataPoolUpdate     = _masterdataPoolUpdate.ToArray();
            request.moveletAssignmentDelete  = _moveletDeleteAssignments.ToArray();
            request.documentPoolUpdate       = _documentPoolUpdate.ToArray();
            request.participantReset         = _ParticipantReset.ToArray();
            request.participantConfiguration = _ParticipantConfigurations.ToArray();

            // clear temps
            _moveletSets.Clear();
            _moveletAssignments.Clear();
            _moveletDeletes.Clear();
            _masterdataPoolUpdate.Clear();
            _documentPoolUpdate.Clear();
            _moveletDeleteAssignments.Clear();
            _ParticipantReset.Clear();
            _ParticipantConfigurations.Clear();

            // clear pools
            _masterdataPoolUpdateTemplates.Clear();
            _documentPoolUpdateTemplates.Clear();

            return(request);
        }
 /// <remarks/>
 public void MovilizerAsync(MovilizerRequest MovilizerRequest) {
     this.MovilizerAsync(MovilizerRequest, null);
 }
 /// <remarks/>
 public System.IAsyncResult BeginMovilizer(MovilizerRequest MovilizerRequest, System.AsyncCallback callback, object asyncState) {
     return this.BeginInvoke("Movilizer", new object[] {
                 MovilizerRequest}, callback, asyncState);
 }
        public MovilizerResponse PostMovilizerRequest(bool synchronousReponse = false, int numResponses = 1000, string requestTrackingKey = "")
        {
            this.Url = MovilizerWebServiceConstants.GetWebServiceUrl();
            // create request object
            MovilizerRequest request = this.ComposeRequest();

            request.synchronousResponse = synchronousReponse;
            request.numResponses        = numResponses;
            request.requestTrackingKey  = requestTrackingKey;

            string debugOutput = Configuration.GetDebugOutputPath();

            if (!String.IsNullOrEmpty(debugOutput))
            {
                XmlHelper.SerializeToFile(debugOutput + "MovilizerRequest.xml", request);
            }

            // consume web service
            MovilizerResponse response = null;
            int countdown = 3;

            while (response == null && countdown > 0)
            {
                try
                {
                    countdown--;
                    response = Movilizer(request);
                }
                catch (Exception e)
                {
                    LogFactory.WriteError(e.ToString());

                    if (countdown > 0)
                    {
                        // sleep for 10 seconds and try again
                        Thread.Sleep(10000);
                    }
                    else if (Configuration.ForceRequeingOnError())
                    {
                        // Requeue waiting message
                        LogFactory.WriteWarning("Error exceeded 3 consecutive retries, reqeuing messages for further processing.");

                        _moveletSets.AddRange(request.moveletSet);
                        _moveletAssignments.AddRange(request.moveletAssignment);
                        request.moveletDelete           = _moveletDeletes.ToArray();
                        request.masterdataPoolUpdate    = _masterdataPoolUpdate.ToArray();
                        request.moveletAssignmentDelete = _moveletDeleteAssignments.ToArray();
                        request.documentPoolUpdate      = _documentPoolUpdate.ToArray();
                        request.participantReset        = _ParticipantReset.ToArray();
                    }
                }
            }

            if (response != null)
            {
                this.EnqueueResponse(response);

                // log status messages
                MovilizerStatusMessage[] statusMessages = response.statusMessage;
                if (statusMessages != null)
                {
                    foreach (MovilizerStatusMessage statusMessage in statusMessages)
                    {
                        LogFactory.WriteEntry(statusMessage);
                    }
                }

                // log movelet errors
                MovilizerMoveletError[] moveletErrors = response.moveletError;
                if (moveletErrors != null)
                {
                    foreach (MovilizerMoveletError moveletError in moveletErrors)
                    {
                        LogFactory.WriteEntry(moveletError);
                    }
                }
            }

            return(response);
        }
Exemple #9
0
        public MovilizerResponse PostMovilizerRequest()
        {
            // refresh the web service url
            MovilizerRequest request = TreatRequest();


            // consume web service
            MovilizerResponse response = null;

            if (Configuration.GetSendToQueues())
            {
                // Enqueue request
                try
                {
                    MessageQueue requestQueue  = new MessageQueue(Configuration.GetRequestQueue());
                    MessageQueue responseQueue = new MessageQueue(Configuration.GetResponseQueue());
                    responseQueue.Formatter = new XmlMessageFormatter(new[] { typeof(MovilizerResponse) });
                    using (MessageQueueTransaction mx = new MessageQueueTransaction())
                    {
                        mx.Begin();
                        requestQueue.Send(request, mx);
                        mx.Commit();
                    }

                    using (MessageQueueTransaction mx = new MessageQueueTransaction())
                    {
                        mx.Begin();
                        response = responseQueue.Receive(new TimeSpan(0, 0, 10), mx).Body as MovilizerResponse;
                        mx.Commit();
                    }
                }
                catch (Exception e)
                {
                    LogFactory.WriteError(e.ToString());
                }
            }
            else
            {
                try
                {
                    response = PostRequest(request);
                }
                catch
                {
                    if (Configuration.ForceRequeingOnError())
                    {
                        // Requeue waiting message
                        LogFactory.WriteWarning("Error exceeded 3 consecutive retries, reqeuing messages for further processing.");

                        _moveletSets.AddRange(request.moveletSet);
                        _moveletAssignments.AddRange(request.moveletAssignment);
                        request.moveletDelete           = _moveletDeletes.ToArray();
                        request.masterdataPoolUpdate    = _masterdataPoolUpdate.ToArray();
                        request.moveletAssignmentDelete = _moveletDeleteAssignments.ToArray();
                        request.documentPoolUpdate      = _documentPoolUpdate.ToArray();
                        request.participantReset        = _moveletParticipantReset.ToArray();
                    }
                }
            }

            if (response != null)
            {
                TreatResponse(response);
            }

            return(response);
        }
        protected MovilizerRequest ComposeRequest()
        {
            // process outbound pools
            ProcessOutboundPool(_masterdataPoolUpdateTemplates);
            ProcessOutboundPool(_documentPoolUpdateTemplates);

            // process outbound queue
            ProcessOutboundQueue(_outQueue);

            // create request
            MovilizerRequest request = new MovilizerRequest();
            InitializeMoveletRequest(request);

            // assign parameters
            request.moveletSet = _moveletSets.ToArray();
            request.moveletAssignment = _moveletAssignments.ToArray();
            request.moveletDelete = _moveletDeletes.ToArray();
            request.masterdataPoolUpdate = _masterdataPoolUpdate.ToArray();
            request.moveletAssignmentDelete = _moveletDeleteAssignments.ToArray();
            request.documentPoolUpdate = _documentPoolUpdate.ToArray();
            request.participantReset = _ParticipantReset.ToArray();
            request.participantConfiguration = _ParticipantConfigurations.ToArray();

            // clear temps
            _moveletSets.Clear();
            _moveletAssignments.Clear();
            _moveletDeletes.Clear();
            _masterdataPoolUpdate.Clear();
            _documentPoolUpdate.Clear();
            _moveletDeleteAssignments.Clear();
            _ParticipantReset.Clear();
            _ParticipantConfigurations.Clear();

            // clear pools
            _masterdataPoolUpdateTemplates.Clear();
            _documentPoolUpdateTemplates.Clear();

            return request;
        }
        private void InitializeMoveletRequest(MovilizerRequest request)
        {
            request.systemId = Configuration.GetSystemId();
            request.systemPassword = Configuration.GetSystemPassword();

            // send acknowlegement key
            request.requestAcknowledgeKey = _requestAckKey;
        }