Exemplo n.º 1
0
        private void InitializePublisherAgent(EntityConfigBase cfg)
        {
            if ((cfg.Interaction & InteractionTypes.Publisher) != InteractionTypes.Publisher)
            {
                return;
            }

            IPublisher p = EntityInstance as IPublisher;

            if (p == null)
            {
                return;
            }

            _publisherAgent = new PushSenderAgent(p, _log);
            foreach (PushChannelConfig c in cfg.PublishConfig.Channels)
            {
                _publisherAgent.RegisterChannel(c);
            }

            _publisherAgent.InitializeChannels();

            if (cfg.PublishConfig.ProcessConfig.IsEnable())
            {
                _publisherAgent.OnProcessing += new OneWayMessageProcessHandler(_publisherAgent_OnProcessing);
                _log.Write(LogType.Debug, "Message processing handler is injected for publisher. " + cfg.EntityID.ToString());
            }
        }
Exemplo n.º 2
0
        private void InitializeRequesterAgent(EntityConfigBase cfg)
        {
            if ((cfg.Interaction & InteractionTypes.Requester) != InteractionTypes.Requester)
            {
                return;
            }

            IRequester p = EntityInstance as IRequester;

            if (p == null)
            {
                return;
            }

            _requesterAgent = new PullSenderAgent(p, _log);
            foreach (PullChannelConfig c in cfg.RequestConfig.Channels)
            {
                _requesterAgent.RegisterChannel(c);
            }

            _requesterAgent.InitializeChannels();

            if (cfg.RequestConfig.ProcessConfig.PreProcessConfig.IsEnable())
            {
                _requesterAgent.OnPreProcessing += new DuplexMessagePreProcessHandler(_requesterAgent_OnPreProcessing);
                _log.Write(LogType.Debug, "Message pre processing handler is injected for requester. " + cfg.EntityID.ToString());
            }

            if (cfg.RequestConfig.ProcessConfig.PostProcessConfig.IsEnable())
            {
                _requesterAgent.OnPostProcessing += new DuplexMessagePostProcessHanlder(_requesterAgent_OnPostProcessing);
                _log.Write(LogType.Debug, "Message post processing handler is injected for requester. " + cfg.EntityID.ToString());
            }
        }
Exemplo n.º 3
0
        public bool InitializeInteraction(InteractionTypes t)
        {
            EntityConfigBase c = EntityConfig;

            if (c == null)
            {
                return(false);
            }

            _log.Write(string.Format("Initializing {0} agent in entity {1}({2}).",
                                     t.ToString(), c.Name, c.EntityID.ToString()));

            if ((t & InteractionTypes.Publisher) == InteractionTypes.Publisher)
            {
                this.InitializePublisherAgent(c);
            }
            if ((t & InteractionTypes.Subscriber) == InteractionTypes.Subscriber)
            {
                this.InitializeSubscriberAgent(c);
            }
            if ((t & InteractionTypes.Requester) == InteractionTypes.Requester)
            {
                this.InitializeRequesterAgent(c);
            }
            if ((t & InteractionTypes.Responser) == InteractionTypes.Responser)
            {
                this.InitializeResponserAgent(c);
            }

            return(true);
        }
Exemplo n.º 4
0
        public void StartPrint(EntityConfigBase data, string text, string caption)
        {
            XmlNode config = GetConfig(data.pageConfig);

            DataFillToXml(data, ref config);
            xmldata = config;
            //初始化页面实体
            pageentity = PageEntityManager <PageEntity> .Getentity(xmldata);

            DefaultPageSettings.Landscape = pageentity.Landscape;
            int       PageWidth  = CmToPix(pageentity.Width);
            int       PageHeigth = CmToPix(pageentity.Height);
            PaperSize p1         = null;

            for (int i = 0; i < PrinterSettings.PaperSizes.Count; i++)
            {
                if (PrinterSettings.PaperSizes[i].PaperName == pageentity.PageName)
                {
                    p1 = PrinterSettings.PaperSizes[i];
                    break;
                }
            }
            if (p1 == null)
            {
                p1 = new PaperSize(pageentity.PageName, PageWidth, PageHeigth);
            }
            DefaultPageSettings.PaperSize = p1;
            PrintShowDialog(text, caption);
        }
Exemplo n.º 5
0
        private void InitializeSubscriberAgent(EntityConfigBase cfg)
        {
            if ((cfg.Interaction & InteractionTypes.Subscriber) != InteractionTypes.Subscriber)
            {
                return;
            }

            ISubscriber s = EntityInstance as ISubscriber;

            if (s == null)
            {
                return;
            }

            _subscriberAgent = new PushReceiverAgent(s, _log);
            foreach (PushChannelConfig c in cfg.SubscribeConfig.Channels)
            {
                _subscriberAgent.RegisterChannel(c);
            }

            _subscriberAgent.InitializeChannels();

            if (cfg.SubscribeConfig.ProcessConfig.IsEnable())
            {
                _subscriberAgent.OnProcessing += new OneWayMessageProcessHandler(_subscriberAgent_OnProcessing);
                _log.Write(LogType.Debug, "Message processing handler is injected for subscriber. " + cfg.EntityID.ToString());
            }
        }
Exemplo n.º 6
0
 private void LoadGeneralInformation(EntityConfigBase cfg)
 {
     this.textBoxEntityID.Text          = cfg.EntityID.ToString();
     this.textBoxEntityName.Text        = cfg.Name;
     this.textBoxEntityDescription.Text = cfg.Description;
     this.textBoxInteraction.Text       = cfg.Interaction.ToString();
 }
Exemplo n.º 7
0
            public bool LoadSetting(EntityConfigBase cfg)
            {
                _entityConfig = cfg;

                RefreshChannelList();
                RefreshChannelButton();

                return(true);
            }
Exemplo n.º 8
0
 private bool CheckDuplicatedEntityName(EntityConfigBase cfg, string ename)
 {
     foreach (EntityContractBase c in Program.SolutionMgt.Config.Entities)
     {
         if (c.EntityID != cfg.EntityID && c.Name == ename)
         {
             return(false);
         }
     }
     return(true);
 }
Exemplo n.º 9
0
        private bool LoadEntity()
        {
            _entity = null;

            Type t = this.comboBoxClassName.SelectedItem as Type;

            if (t == null)
            {
                return(false);
            }

            E e = EntityLoader.CreateEntry <E>(t);

            _entry = e;

            if (e == null)
            {
                _log.Write(EntityLoader.LastError);
                MessageBox.Show(this, "Initialize message entity failed.", "Error",
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            _entity                  = new EntityAssemblyConfig();
            _entity.ClassName        = t.ToString();
            _entity.AssemblyLocation = this.textBoxAssemblyLocation.Text.Trim();
            _entity.InitializeArgument.ConfigFilePath = this.textBoxConfigPath.Text.Trim();

            if (!e.Initialize(_entity.InitializeArgument))
            {
                MessageBox.Show(this, "Initialize message entity failed.", "Error",
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            EntityConfigBase cfg = e.GetConfiguration();

            _cfg = cfg;

            if (cfg == null)
            {
                MessageBox.Show(this, "Initialize message entity failed.", "Error",
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            this.textBoxEntityName.Text        = _entity.EntityInfo.Name = cfg.Name;
            this.textBoxEntityID.Text          = (_entity.EntityInfo.EntityID = cfg.EntityID).ToString();
            this.textBoxEntityDescription.Text = _entity.EntityInfo.Description = cfg.Description;

            return(true);
        }
Exemplo n.º 10
0
        private bool SaveGeneralInformation(EntityConfigBase cfg)
        {
            string ename = this.textBoxEntityName.Text.Trim();

            if (!CheckDuplicatedEntityName(cfg, ename))
            {
                MessageBox.Show(this, "Message Entity \"" + ename + "\" has already exsited, please input another name.",
                                "Warning", MessageBoxButtons.OK, MessageBoxIcon.Information);
                SelectTabPage(this.tabPageGeneral);
                this.textBoxEntityName.Focus();
                return(false);
            }

            cfg.Name        = ename;
            cfg.Description = this.textBoxEntityDescription.Text;
            cfg.EntityID    = new Guid(this.textBoxEntityID.Text.Trim());
            cfg.Interaction = (InteractionTypes)Enum.Parse(typeof(InteractionTypes), this.textBoxInteraction.Text.Trim());

            return(true);
        }
Exemplo n.º 11
0
        public bool Initialize(EntityInitializeArgument arg)
        {
            IMessageEntity e = EntityInstance;

            if (e == null)
            {
                return(false);
            }

            if (!e.Initialize(arg))
            {
                _log.Write("Initialize message entity failed. " + ToString());
                return(false);
            }

            EntityConfigBase c = EntityConfig;

            if (c == null)
            {
                return(false);
            }

            return(true);
        }
Exemplo n.º 12
0
        private void LoadTransformPage()
        {
            _entityCfg = _entityConfig.GetConfiguration();
            if (_entityCfg == null)
            {
                return;
            }

            // Note: assume that an entity should be publisher or subcriber, not both of them.

            if ((_entityCfg.Interaction & InteractionTypes.Publisher) == InteractionTypes.Publisher &&
                _entityCfg.PublishConfig != null)
            {
                this.panelOneWayTransform.Visible = true;
                //this.checkBoxXSLT.Text = string.Format(this.checkBoxXSLT.Text, "sending to subscriber");
                this.checkBoxXSLT.Text    = string.Format(this.checkBoxXSLT.Text, "sending to publish channel");
                this.checkBoxXSLT.Checked = _entityCfg.PublishConfig.ProcessConfig.EnableXSLTTransform;
                this.textBoxXSLT.Text     = _entityCfg.PublishConfig.ProcessConfig.XSLTFileLocation;
            }
            else if ((_entityCfg.Interaction & InteractionTypes.Subscriber) == InteractionTypes.Subscriber &&
                     _entityCfg.SubscribeConfig != null)
            {
                this.panelOneWayTransform.Visible = true;
                //this.checkBoxXSLT.Text = string.Format(this.checkBoxXSLT.Text, "receiving from publisher");
                this.checkBoxXSLT.Text    = string.Format(this.checkBoxXSLT.Text, "receiving from publish channel");
                this.checkBoxXSLT.Checked = _entityCfg.SubscribeConfig.ProcessConfig.EnableXSLTTransform;
                this.textBoxXSLT.Text     = _entityCfg.SubscribeConfig.ProcessConfig.XSLTFileLocation;
            }
            else
            {
                this.panelOneWayTransform.Visible = false;
            }

            // Note: assume that an entity should be requseter or responser, not both of them.

            if ((_entityCfg.Interaction & InteractionTypes.Requester) == InteractionTypes.Requester &&
                _entityCfg.RequestConfig != null)
            {
                this.panelDuplexTransform.Visible = true;
                //this.checkBoxXSLTRequest.Text = string.Format(this.checkBoxXSLTRequest.Text, "sending to responser");
                this.checkBoxXSLTRequest.Text    = string.Format(this.checkBoxXSLTRequest.Text, "sending to request channel");
                this.checkBoxXSLTRequest.Checked = _entityCfg.RequestConfig.ProcessConfig.PreProcessConfig.EnableXSLTTransform;
                this.textBoxXSLTRequest.Text     = _entityCfg.RequestConfig.ProcessConfig.PreProcessConfig.XSLTFileLocation;
                //this.checkBoxXSLTResponse.Text = string.Format(this.checkBoxXSLTResponse.Text, "receiving from responser");
                this.checkBoxXSLTResponse.Text    = string.Format(this.checkBoxXSLTResponse.Text, "receiving from request channel");
                this.checkBoxXSLTResponse.Checked = _entityCfg.RequestConfig.ProcessConfig.PostProcessConfig.EnableXSLTTransform;
                this.textBoxXSLTResponse.Text     = _entityCfg.RequestConfig.ProcessConfig.PostProcessConfig.XSLTFileLocation;
            }
            else if ((_entityCfg.Interaction & InteractionTypes.Responser) == InteractionTypes.Responser &&
                     _entityCfg.ResponseConfig != null)
            {
                this.panelDuplexTransform.Visible = true;
                //this.checkBoxXSLTRequest.Text = string.Format(this.checkBoxXSLTRequest.Text, "receiving from requester");
                this.checkBoxXSLTRequest.Text    = string.Format(this.checkBoxXSLTRequest.Text, "receiving from request channel");
                this.checkBoxXSLTRequest.Checked = _entityCfg.ResponseConfig.ProcessConfig.PreProcessConfig.EnableXSLTTransform;
                this.textBoxXSLTRequest.Text     = _entityCfg.ResponseConfig.ProcessConfig.PreProcessConfig.XSLTFileLocation;
                //this.checkBoxXSLTResponse.Text = string.Format(this.checkBoxXSLTResponse.Text, "sending to requester");
                this.checkBoxXSLTResponse.Text    = string.Format(this.checkBoxXSLTResponse.Text, "sending to request channel");
                this.checkBoxXSLTResponse.Checked = _entityCfg.ResponseConfig.ProcessConfig.PostProcessConfig.EnableXSLTTransform;
                this.textBoxXSLTResponse.Text     = _entityCfg.ResponseConfig.ProcessConfig.PostProcessConfig.XSLTFileLocation;
            }
            else
            {
                this.panelDuplexTransform.Visible = false;
            }

            if (this.panelOneWayTransform.Visible == false && this.panelDuplexTransform.Visible == true)
            {
                this.panelDuplexTransform.Location = this.panelOneWayTransform.Location;
            }
        }
Exemplo n.º 13
0
        static void RegisterEntityIntoSolution()
        {
            try
            {
                EntityAssemblyConfig entity = Program.ConfigMgt.Config.EntityAssembly;
                foreach (EntityContractBase e in SolutionMgt.Config.Entities)
                {
                    if (e.EntityID == entity.EntityInfo.EntityID)
                    {
                        MessageBox.Show("Following message entity has already existed in the integration solution.\r\n\r\n"
                                        + entity.EntityInfo.Name + " (" + entity.EntityInfo.EntityID + ")",
                                        "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        return;
                    }
                }

                EntityConfigAgent agent = new EntityConfigAgent(Program.ConfigMgt.Config.EntityAssembly, Program.Log);
                if (agent.Initialize(Program.ConfigMgt.Config.EntityAssembly.InitializeArgument))
                {
                    EntityConfigBase   cfg = agent.EntityConfig;
                    EntityContractBase c   = new EntityContractBase();

                    c.Name        = cfg.Name;
                    c.DeviceName  = cfg.DeviceName;
                    c.Direction   = cfg.Direction;
                    c.Interaction = cfg.Interaction;
                    c.Description = cfg.Description;
                    c.EntityID    = cfg.EntityID;
                    if (cfg.PublishConfig != null)
                    {
                        c.Publication = cfg.PublishConfig.Publication;
                    }
                    if (cfg.ResponseConfig != null)
                    {
                        c.ResponseDescription = cfg.ResponseConfig.ResponseContract;
                    }
                    c.AssemblyConfig = GetEntityAssemblyConfigForSolution(entity);

                    //string webConfigFilePath = Path.Combine(Application.StartupPath, EntityWebConfig.EntityWebConfigFileName);
                    //ConfigManager<EntityWebConfig> webmgt = new ConfigManager<EntityWebConfig>(webConfigFilePath);
                    //if (webmgt.Load())
                    //{
                    //    Log.Write("Register entity with default web config at: " + webConfigFilePath);
                    //    SolutionMgt.Config.RegisterEntity(c, webmgt.Config);
                    //}
                    //else
                    //{
                    //    Log.Write("Register entity without default web config.");
                    //    SolutionMgt.Config.RegisterEntity(c);
                    //}

                    Log.Write("Registering entity.");
                    SolutionMgt.Config.RegisterEntity(c);

                    if (SolutionMgt.Save())
                    {
                        Log.Write("Save solution dir file succeeded. " + SolutionMgt.FileName);

                        MessageBox.Show("Register following message entity into the integration solution succeeded.\r\n\r\n"
                                        + entity.EntityInfo.Name + " (" + entity.EntityInfo.EntityID + ")",
                                        "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                    else
                    {
                        Log.Write(LogType.Error, "Save solution dir file failed.");
                        Log.Write(SolutionMgt.LastError);

                        MessageBox.Show("Register following message entity into the integration solution failed.\r\n\r\n"
                                        + entity.EntityInfo.Name + " (" + entity.EntityInfo.EntityID + ")",
                                        "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }

                    agent.Uninitialize();
                }
            }
            catch (Exception err)
            {
                Log.Write(err);
            }
        }
Exemplo n.º 14
0
        protected void DataFillToXml(object data, ref XmlNode config)
        {
            PropertyInfo[] zz = data.GetType().GetProperties();
            for (int n = 0; n < config.ChildNodes.Count; n++)
            {
                string configType = config.ChildNodes[n].Name;
                switch (configType)
                {
                case "text":
                    foreach (PropertyInfo x in zz)
                    {
                        if (config.ChildNodes[n].Attributes["DataFieldName"] != null)
                        {
                            if (Convert.ToString(config.ChildNodes[n].Attributes["DataFieldName"].Value) == x.Name)
                            {
                                config.ChildNodes[n].Attributes["value"].Value = Convert.ToString(x.GetValue(data, null));
                                break;
                            }
                        }
                    }
                    break;

                case "loop":
                    List <XmlNode> l = new List <XmlNode>();
                    foreach (PropertyInfo x in zz)
                    {
                        if (Convert.ToString(config.ChildNodes[n].Attributes["DataFieldName"].Value) == x.Name)
                        {
                            EntityConfigBase[] list = (EntityConfigBase[])x.GetValue(data, null);
                            if (list != null)
                            {
                                //数据的偏移量
                                decimal y = 0;
                                if (list.Length > 0)
                                {
                                    PropertyInfo[] mm = list[0].GetType().GetProperties();
                                    for (int i = 0; i < list.Length; i++)
                                    {
                                        //每行数据的初始偏移量
                                        decimal          yyy = y;
                                        EntityConfigBase d   = list[i];
                                        foreach (XmlNode r in config.ChildNodes[n].ChildNodes)
                                        {
                                            //记录该行最大的偏移量
                                            decimal yy = yyy;
                                            foreach (PropertyInfo z in mm)
                                            {
                                                if (r.Attributes["DataFieldName"] != null)
                                                {
                                                    if (Convert.ToString(r.Attributes["DataFieldName"].Value) == z.Name)
                                                    {
                                                        FormatXML_Loop(r, ref yy, ref l, Convert.ToString(z.GetValue(d, null)));
                                                        XmlNode b = r.Clone();
                                                        l.Add(b);
                                                        if (yy > y)
                                                        {
                                                            y = yy;
                                                        }
                                                        break;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    config.ChildNodes[n].RemoveAll();
                    foreach (XmlNode newxml in l)
                    {
                        config.ChildNodes[n].AppendChild(newxml);
                    }
                    break;

                default: break;
                }
            }
        }
Exemplo n.º 15
0
 public void StartPrint(EntityConfigBase data)
 {
     StartPrint(data, string.Empty, string.Empty);
 }
Exemplo n.º 16
0
        static void AddAndApplyChannel(string[] args)
        {
            int count = 6;

            if (args.Length < count)
            {
                Program.Log.Write("Arguement is not enough.");
                return;
            }

            try
            {
                string type         = args[1];
                string entityID     = args[2];
                string entityName   = args[3];
                string messageType  = args[4];
                string protocolType = args[5];

                switch (type.ToLowerInvariant())
                {
                case "publisher":
                {
                    MessageType mt = MessageType.Parse(messageType);
                    if (mt == null)
                    {
                        Program.Log.Write("Message Type can not be parse from: " + messageType);
                        return;
                    }

                    PushChannelConfig c = new PushChannelConfig();
                    c.ReceiverEntityID   = Program.ConfigMgt.Config.EntityAssembly.EntityInfo.EntityID;
                    c.ReceiverEntityName = Program.ConfigMgt.Config.EntityAssembly.EntityInfo.Name;
                    c.ProtocolType       = (ProtocolType)Enum.Parse(typeof(ProtocolType), protocolType);
                    c.Subscription.Type  = RoutingRuleType.MessageType;
                    c.Subscription.MessageTypeList.Add(mt);
                    c.SenderEntityID   = new Guid(entityID);
                    c.SenderEntityName = entityName;

                    switch (c.ProtocolType)
                    {
                    case ProtocolType.LPC: ChannelHelper.GenerateLPCChannel(c); break;

                    case ProtocolType.MSMQ: ChannelHelper.GenerateMSMQChannel(c); break;

                    default: Program.Log.Write("Following protocol type is not supported by now: " + c.ProtocolType.ToString()); return;
                    }

                    EntityConfigAgent agent = new EntityConfigAgent(Program.ConfigMgt.Config.EntityAssembly, Program.Log);
                    if (agent.Initialize(Program.ConfigMgt.Config.EntityAssembly.InitializeArgument))
                    {
                        EntityConfigBase cfg = agent.EntityConfig;
                        if (cfg == null)
                        {
                            Program.Log.Write("Cannot read configuration file.");
                        }
                        else
                        {
                            if (cfg.SubscribeConfig == null)
                            {
                                cfg.SubscribeConfig = new SubscribeConfig();
                            }
                            cfg.SubscribeConfig.Channels.Add(c);

                            if (agent.EntityConfigInstance.SaveConfiguration())
                            {
                                Program.Log.Write("Write configuration file successfully.");
                            }
                            else
                            {
                                Program.Log.Write("Cannot write configuration file.");
                            }
                        }
                        agent.Uninitialize();
                    }
                    break;
                }

                case "responser":
                {
                    PullChannelConfig c = new PullChannelConfig();
                    c.ReceiverEntityID   = Program.ConfigMgt.Config.EntityAssembly.EntityInfo.EntityID;
                    c.ReceiverEntityName = Program.ConfigMgt.Config.EntityAssembly.EntityInfo.Name;
                    c.ProtocolType       = (ProtocolType)Enum.Parse(typeof(ProtocolType), protocolType);
                    c.SenderEntityID     = new Guid(entityID);
                    c.SenderEntityName   = entityName;

                    switch (c.ProtocolType)
                    {
                    case ProtocolType.LPC: ChannelHelper.GenerateLPCChannel(c); break;

                    default: Program.Log.Write("Following protocol type is not supported by now: " + c.ProtocolType.ToString()); return;
                    }

                    EntityConfigAgent agent = new EntityConfigAgent(Program.ConfigMgt.Config.EntityAssembly, Program.Log);
                    if (agent.Initialize(Program.ConfigMgt.Config.EntityAssembly.InitializeArgument))
                    {
                        EntityConfigBase cfg = agent.EntityConfig;
                        if (cfg == null)
                        {
                            Program.Log.Write("Cannot read configuration file.");
                        }
                        else
                        {
                            if (cfg.RequestConfig == null)
                            {
                                cfg.RequestConfig = new RequestConfig();
                            }
                            cfg.RequestConfig.Channels.Add(c);

                            if (agent.EntityConfigInstance.SaveConfiguration())
                            {
                                Program.Log.Write("Write configuration file successfully.");
                            }
                            else
                            {
                                Program.Log.Write("Cannot write configuration file.");
                            }
                        }
                        agent.Uninitialize();
                    }
                    break;
                }
                }
            }
            catch (Exception err)
            {
                Program.Log.Write(err);
            }

            ApplyChannelConfigurations(false);
        }
Exemplo n.º 17
0
        private void LoadSetting()
        {
            EntityConfigBase cfg = _agent.EntityConfig;

            _config = cfg;

            this.tabControlMain.TabPages.Clear();
            this.tabControlMain.TabPages.Add(this.tabPageGeneral);
            LoadGeneralInformation(cfg);

            if ((cfg.Interaction & InteractionTypes.Subscriber) == InteractionTypes.Subscriber)
            {
                this.tabControlMain.TabPages.Add(this.tabPageSubscribe);
                SubscribeConfigControler ctrl = new SubscribeConfigControler(this);
                this.tabPageSubscribe.Tag = ctrl;
                ctrl.LoadSetting(cfg);
                _fxGUIList.Add(ctrl);
            }

            if ((cfg.Interaction & InteractionTypes.Responser) == InteractionTypes.Responser)
            {
                this.tabControlMain.TabPages.Add(this.tabPageResponse);
                ResponseConfigControler ctrl = new ResponseConfigControler(this);
                this.tabPageResponse.Tag = ctrl;
                ctrl.LoadSetting(cfg);
                _fxGUIList.Add(ctrl);
            }

            IConfigUI[] guiList = _agent.EntityConfigInstance.GetIConfigUI();
            if (guiList != null)
            {
                foreach (IConfigUI gui in guiList)
                {
                    string  title = gui.Title;
                    Control ctl   = gui.GetControl();
                    if (ctl != null)
                    {
                        TabPage page = new TabPage(title);
                        page.AutoScroll = true;
                        page.Tag        = gui;

                        EntityLoader.PrepareControl(ctl, this);
                        page.Controls.Add(ctl);
                        this.tabControlMain.TabPages.Add(page);
                        gui.LoadConfig();
                    }

                    _entityGUIList.Add(gui);
                }
            }

            if ((cfg.Interaction & InteractionTypes.Publisher) == InteractionTypes.Publisher)
            {
                this.tabControlMain.TabPages.Add(this.tabPagePublish);
                PublishConfigControler ctrl = new PublishConfigControler(this);
                this.tabPagePublish.Tag = ctrl;
                ctrl.LoadSetting(cfg);
                _fxGUIList.Add(ctrl);
            }

            if ((cfg.Interaction & InteractionTypes.Requester) == InteractionTypes.Requester)
            {
                this.tabControlMain.TabPages.Add(this.tabPageRequest);
                RequestConfigControler ctrl = new RequestConfigControler(this);
                this.tabPageRequest.Tag = ctrl;
                ctrl.LoadSetting(cfg);
                _fxGUIList.Add(ctrl);
            }
        }
Exemplo n.º 18
0
        static void DeleteChannel(string[] args)
        {
            int count = 3;

            if (args.Length < count)
            {
                Program.Log.Write("Arguement is not enough.");
                return;
            }

            try
            {
                string type     = args[1];
                string entityID = args[2];
                Guid   eID      = new Guid(entityID);

                switch (type.ToLowerInvariant())
                {
                case "publisher":
                {
                    EntityConfigAgent agent = new EntityConfigAgent(Program.ConfigMgt.Config.EntityAssembly, Program.Log);
                    if (agent.Initialize(Program.ConfigMgt.Config.EntityAssembly.InitializeArgument))
                    {
                        EntityConfigBase cfg = agent.EntityConfig;
                        if (cfg == null || cfg.SubscribeConfig == null)
                        {
                            Program.Log.Write("Cannot read SubscribeConfig from configuration file.");
                        }
                        else
                        {
                            List <PushChannelConfig> dlist = new List <PushChannelConfig>();
                            foreach (PushChannelConfig c in cfg.SubscribeConfig.Channels)
                            {
                                if (c.SenderEntityID == eID)
                                {
                                    dlist.Add(c);
                                }
                            }
                            foreach (PushChannelConfig c in dlist)
                            {
                                cfg.SubscribeConfig.Channels.Remove(c);
                            }
                            agent.EntityConfigInstance.SaveConfiguration();
                        }
                        agent.Uninitialize();
                    }
                    break;
                }

                case "responser":
                {
                    EntityConfigAgent agent = new EntityConfigAgent(Program.ConfigMgt.Config.EntityAssembly, Program.Log);
                    if (agent.Initialize(Program.ConfigMgt.Config.EntityAssembly.InitializeArgument))
                    {
                        EntityConfigBase cfg = agent.EntityConfig;
                        if (cfg == null || cfg.RequestConfig == null)
                        {
                            Program.Log.Write("Cannot read SubscribeConfig from configuration file.");
                        }
                        else
                        {
                            List <PushChannelConfig> dlist = new List <PushChannelConfig>();
                            foreach (PushChannelConfig c in cfg.RequestConfig.Channels)
                            {
                                if (c.ReceiverEntityID == eID)
                                {
                                    dlist.Add(c);
                                }
                            }
                            foreach (PushChannelConfig c in dlist)
                            {
                                cfg.RequestConfig.Channels.Remove(c);
                            }
                            agent.EntityConfigInstance.SaveConfiguration();
                        }
                        agent.Uninitialize();
                    }
                    break;
                }
                }
            }
            catch (Exception err)
            {
                Log.Write(err);
            }
        }
Exemplo n.º 19
0
        static bool UpdateChannelInResponser(PullChannelConfig cfg)
        {
            EntityAssemblyConfig acfg = null;

            foreach (EntityContractBase c in Program.SolutionMgt.Config.Entities)
            {
                if (c.EntityID == cfg.ReceiverEntityID)
                {
                    acfg = c.AssemblyConfig;
                    break;
                }
            }

            if (acfg == null)
            {
                Program.Log.Write(LogType.Error, "Cannot find responser in the integration solution: "
                                  + cfg.ReceiverEntityName + " (" + cfg.ReceiverEntityID + ")");
                return(false);
            }

            bool ret = false;

            acfg = GetEntityAssemblyConfigForEntity(acfg);
            EntityConfigAgent agent = new EntityConfigAgent(acfg, Program.Log);

            if (agent.Initialize(acfg.InitializeArgument))
            {
                EntityConfigBase ecfg = agent.EntityConfig;
                if (ecfg == null)
                {
                    Program.Log.Write(LogType.Error, "Cannot get responser configuration: "
                                      + cfg.ReceiverEntityName + " (" + cfg.ReceiverEntityID + ")");
                }
                else
                {
                    List <PullChannelConfig> deleteList = new List <PullChannelConfig>();
                    foreach (PullChannelConfig chn in ecfg.ResponseConfig.Channels)
                    {
                        if (chn.SenderEntityID == cfg.SenderEntityID)
                        {
                            deleteList.Add(chn);
                            break;
                        }
                    }

                    foreach (PullChannelConfig chn in deleteList)
                    {
                        ecfg.ResponseConfig.Channels.Remove(chn);
                    }

                    ecfg.ResponseConfig.Channels.Add(cfg);

                    if (agent.EntityConfigInstance.SaveConfiguration())
                    {
                        ret = true;
                        Program.Log.Write("Save responser configuration succeeded: "
                                          + cfg.ReceiverEntityName + " (" + cfg.ReceiverEntityID + ")");
                    }
                    else
                    {
                        Program.Log.Write(LogType.Error, "Save responser configuration failed: "
                                          + cfg.ReceiverEntityName + " (" + cfg.ReceiverEntityID + ")");
                    }
                }

                agent.Uninitialize();
            }

            return(ret);
        }
Exemplo n.º 20
0
        static void ApplyChannelConfigurations(bool showMsg)
        {
            try
            {
                EntityConfigAgent agent = new EntityConfigAgent(Program.ConfigMgt.Config.EntityAssembly, Program.Log);
                if (agent.Initialize(Program.ConfigMgt.Config.EntityAssembly.InitializeArgument))
                {
                    EntityConfigBase cfg = agent.EntityConfig;

                    if ((cfg.Interaction & InteractionTypes.Subscriber) == InteractionTypes.Subscriber)
                    {
                        bool res = true;
                        foreach (PushChannelConfig chn in cfg.SubscribeConfig.Channels)
                        {
                            if (!UpdateChannelInPublisher(chn))
                            {
                                res = false;
                                break;
                            }
                        }

                        if (res)
                        {
                            string str = "Apply channels to publisher succeeded.";
                            Log.Write(str);

                            if (showMsg)
                            {
                                MessageBox.Show(str, "Information",
                                                MessageBoxButtons.OK, MessageBoxIcon.Information);
                            }
                        }
                        else
                        {
                            string str = "Apply channels to publisher failed.";
                            Log.Write(LogType.Error, str);

                            if (showMsg)
                            {
                                MessageBox.Show(str, "Error",
                                                MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }
                        }
                    }

                    if ((cfg.Interaction & InteractionTypes.Requester) == InteractionTypes.Requester)
                    {
                        bool res = true;
                        foreach (PullChannelConfig chn in cfg.RequestConfig.Channels)
                        {
                            if (!UpdateChannelInResponser(chn))
                            {
                                res = false;
                                break;
                            }
                        }

                        if (res)
                        {
                            string str = "Apply channels to responser succeeded.";
                            Log.Write(str);

                            if (showMsg)
                            {
                                MessageBox.Show(str, "Information",
                                                MessageBoxButtons.OK, MessageBoxIcon.Information);
                            }
                        }
                        else
                        {
                            string str = "Apply channels to responser failed.";
                            Log.Write(LogType.Error, str);

                            if (showMsg)
                            {
                                MessageBox.Show(str, "Error",
                                                MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }
                        }
                    }

                    //else
                    //{
                    //    MessageBox.Show("No channel need to be applied.", "Information",
                    //        MessageBoxButtons.OK, MessageBoxIcon.Information);
                    //}

                    agent.Uninitialize();
                }
            }
            catch (Exception err)
            {
                Log.Write(err);
            }
        }