public override string Generate(ThoughtWorks.CruiseControl.Core.IIntegrationResult integrationResult)
        {
            string encodedDate = EncodeDate();
            Version lastVersion;

            try
            {
                lastVersion = new Version(integrationResult.Label);
            }
            catch (ArgumentException)
            {
                lastVersion = new Version();
            }

            int newRevisionNumber = lastVersion.Revision + 1;
            if (lastVersion.Major != Major ||
                lastVersion.Minor != Minor ||
                lastVersion.Build.ToString() != encodedDate)
            {
                newRevisionNumber = 0;
            }

            return string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0}.{1}.{2}.{3}",
                Major, Minor, encodedDate, newRevisionNumber);
        }
        private void Monitor_MessageReceived(string projectName, ThoughtWorks.CruiseControl.Remote.Message message)
		{
            // filter out unwanted messages, this should only allow messages that are not 'build' related
            // example of messages to allow : fixing the build, aborted the build, ...
            if (message.Kind == Remote.Message.MessageKind.NotDefined) return;
            trayIcon.ShowBalloonTip(5000, projectName, message.ToString(), ToolTipIcon.Info);
		}
 protected ComponentFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, 
     string gridPath, int rowIndex, string path)
 {
     Silvernium = silvernium;
     GridPath = gridPath;
     RowIndex = rowIndex;
     Path = path;
     AssertPathPresent(gridPath, rowIndex, path);
 }
 public DataRowFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, string path, int index)
     : base(silvernium, path)
 {
     Index = index;
 }
示例#5
0
 private void Monitor_MessageReceived(string projectName, ThoughtWorks.CruiseControl.Remote.Message message)
 {
     trayIcon.ShowBalloonTip(5000, projectName, message.ToString(), ToolTipIcon.Info);
 }
		private void ProjectMonitor_MessageReceived(string projectName, ThoughtWorks.CruiseControl.Remote.Message message)
		{
            if (MessageReceived != null)
            {
                var canInvoke = true;
                if (synchronizeInvoke is Control) canInvoke = !(synchronizeInvoke as Control).IsDisposed;

                string caption = string.Concat("Project Name : ", projectName);

                if (canInvoke) synchronizeInvoke.BeginInvoke(MessageReceived, new object[] { caption, message });
            }
		}
        int AjusteQRVersion(string TextoEncode, ThoughtWorks.QRCode.Codec.QRCodeEncoder.ERROR_CORRECTION qrCodeErrorCorrect)
        {
            byte[] textoByte = UTF8Encoding.UTF8.GetBytes(TextoEncode);
            int bits = ((textoByte.Length + 1) * 8) + 8;

            switch (qrCodeErrorCorrect)
            {
                case QRCodeEncoder.ERROR_CORRECTION.L:
                    #region Evaluacion error Bajo (7%)

                    if (bits <= 23648)
                    {
                        if (bits <= 22496)
                        {
                            if (bits <= 21616)
                            {
                                if (bits <= 20528)
                                {
                                    if (bits <= 19472)
                                    {
                                        if (bits <= 18448)
                                        {
                                            if (bits <= 17528)
                                            {
                                                if (bits <= 16568)
                                                {
                                                    if (bits <= 15640)
                                                    {
                                                        if (bits <= 14744)
                                                        {
                                                            if (bits <= 13880)
                                                            {
                                                                if (bits <= 13048)
                                                                {
                                                                    if (bits <= 12248)
                                                                    {
                                                                        if (bits <= 11744)
                                                                        {
                                                                            if (bits <= 10960)
                                                                            {
                                                                                if (bits <= 10208)
                                                                                {
                                                                                    if (bits <= 9392)
                                                                                    {
                                                                                        if (bits <= 8752)
                                                                                        {
                                                                                            if (bits <= 8048)
                                                                                            {
                                                                                                if (bits <= 7456)
                                                                                                {
                                                                                                    if (bits <= 6888)
                                                                                                    {
                                                                                                        if (bits <= 6360)
                                                                                                        {
                                                                                                            if (bits <= 5768)
                                                                                                            {
                                                                                                                if (bits <= 5176)
                                                                                                                {
                                                                                                                    if (bits <= 4712)
                                                                                                                    {
                                                                                                                        if (bits <= 4184)
                                                                                                                        {
                                                                                                                            if (bits <= 3688)
                                                                                                                            {
                                                                                                                                if (bits <= 3424)
                                                                                                                                {
                                                                                                                                    if (bits <= 2960)
                                                                                                                                    {
                                                                                                                                        if (bits <= 2592)
                                                                                                                                        {
                                                                                                                                            if (bits <= 2192)
                                                                                                                                            {
                                                                                                                                                if (bits <= 1856)
                                                                                                                                                {
                                                                                                                                                    if (bits <= 1552)
                                                                                                                                                    {
                                                                                                                                                        if (bits <= 1248)
                                                                                                                                                        {
                                                                                                                                                            if (bits <= 1088)
                                                                                                                                                            {
                                                                                                                                                                if (bits <= 864)
                                                                                                                                                                {
                                                                                                                                                                    if (bits <= 640)
                                                                                                                                                                    {
                                                                                                                                                                        if (bits <= 440)
                                                                                                                                                                        {
                                                                                                                                                                            if (bits <= 272)
                                                                                                                                                                            {
                                                                                                                                                                                if (bits <= 152)
                                                                                                                                                                                {
                                                                                                                                                                                    return 1;
                                                                                                                                                                                }
                                                                                                                                                                                return 2;
                                                                                                                                                                            }
                                                                                                                                                                            return 3;
                                                                                                                                                                        }
                                                                                                                                                                        return 4;
                                                                                                                                                                    }
                                                                                                                                                                    return 5;
                                                                                                                                                                }
                                                                                                                                                                return 6;
                                                                                                                                                            }
                                                                                                                                                            return 7;
                                                                                                                                                        }
                                                                                                                                                        return 8;
                                                                                                                                                    }
                                                                                                                                                    return 9;
                                                                                                                                                }
                                                                                                                                                return 10;
                                                                                                                                            }
                                                                                                                                            return 11;
                                                                                                                                        }
                                                                                                                                        return 12;
                                                                                                                                    }
                                                                                                                                    return 13;
                                                                                                                                }
                                                                                                                                return 14;
                                                                                                                            }
                                                                                                                            return 15;
                                                                                                                        }
                                                                                                                        return 16;
                                                                                                                    }
                                                                                                                    return 17;
                                                                                                                }
                                                                                                                return 18;
                                                                                                            }
                                                                                                            return 19;
                                                                                                        }
                                                                                                        return 20;
                                                                                                    }
                                                                                                    return 21;
                                                                                                }
                                                                                                return 22;
                                                                                            }
                                                                                            return 23;
                                                                                        }
                                                                                        return 24;
                                                                                    }
                                                                                    return 25;
                                                                                }
                                                                                return 26;
                                                                            }
                                                                            return 27;
                                                                        }
                                                                        return 28;
                                                                    }
                                                                    return 29;
                                                                }
                                                                return 30;
                                                            }
                                                            return 31;
                                                        }
                                                        return 32;
                                                    }
                                                    return 33;
                                                }
                                                return 34;
                                            }
                                            return 35;
                                        }
                                        return 36;
                                    }
                                    return 37;
                                }
                                return 38;
                            }
                            return 39;
                        }
                        return 40;
                    }

                    #endregion
                    break;

                case QRCodeEncoder.ERROR_CORRECTION.M:
                    #region Evaluacion error Medio (15%)

                    if (bits <= 18672)
                    {
                        if (bits <= 17728)
                        {
                            if (bits <= 16816)
                            {
                                if (bits <= 15936)
                                {
                                    if (bits <= 15312)
                                    {
                                        if (bits <= 14496)
                                        {
                                            if (bits <= 13800)
                                            {
                                                if (bits <= 13048)
                                                {
                                                    if (bits <= 12328)
                                                    {
                                                        if (bits <= 11640)
                                                        {
                                                            if (bits <= 10984)
                                                            {
                                                                if (bits <= 10136)
                                                                {
                                                                    if (bits <= 9544)
                                                                    {
                                                                        if (bits <= 9024)
                                                                        {
                                                                            if (bits <= 8496)
                                                                            {
                                                                                if (bits <= 8000)
                                                                                {
                                                                                    if (bits <= 7312)
                                                                                    {
                                                                                        if (bits <= 6880)
                                                                                        {
                                                                                            if (bits <= 6256)
                                                                                            {
                                                                                                if (bits <= 5712)
                                                                                                {
                                                                                                    if (bits <= 5352)
                                                                                                    {
                                                                                                        if (bits <= 5016)
                                                                                                        {
                                                                                                            if (bits <= 4504)
                                                                                                            {
                                                                                                                if (bits <= 4056)
                                                                                                                {
                                                                                                                    if (bits <= 3624)
                                                                                                                    {
                                                                                                                        if (bits <= 3320)
                                                                                                                        {
                                                                                                                            if (bits <= 2920)
                                                                                                                            {
                                                                                                                                if (bits <= 2672)
                                                                                                                                {
                                                                                                                                    if (bits <= 2320)
                                                                                                                                    {
                                                                                                                                        if (bits <= 2032)
                                                                                                                                        {
                                                                                                                                            if (bits <= 1728)
                                                                                                                                            {
                                                                                                                                                if (bits <= 1456)
                                                                                                                                                {
                                                                                                                                                    if (bits <= 1232)
                                                                                                                                                    {
                                                                                                                                                        if (bits <= 992)
                                                                                                                                                        {
                                                                                                                                                            if (bits <= 864)
                                                                                                                                                            {
                                                                                                                                                                if (bits <= 688)
                                                                                                                                                                {
                                                                                                                                                                    if (bits <= 512)
                                                                                                                                                                    {
                                                                                                                                                                        if (bits <= 352)
                                                                                                                                                                        {
                                                                                                                                                                            if (bits <= 224)
                                                                                                                                                                            {
                                                                                                                                                                                if (bits <= 128)
                                                                                                                                                                                {
                                                                                                                                                                                    return 1;
                                                                                                                                                                                }
                                                                                                                                                                                return 2;
                                                                                                                                                                            }
                                                                                                                                                                            return 3;
                                                                                                                                                                        }
                                                                                                                                                                        return 4;
                                                                                                                                                                    }
                                                                                                                                                                    return 5;
                                                                                                                                                                }
                                                                                                                                                                return 6;
                                                                                                                                                            }
                                                                                                                                                            return 7;
                                                                                                                                                        }
                                                                                                                                                        return 8;
                                                                                                                                                    }
                                                                                                                                                    return 9;
                                                                                                                                                }
                                                                                                                                                return 10;
                                                                                                                                            }
                                                                                                                                            return 11;
                                                                                                                                        }
                                                                                                                                        return 12;
                                                                                                                                    }
                                                                                                                                    return 13;
                                                                                                                                }
                                                                                                                                return 14;
                                                                                                                            }
                                                                                                                            return 15;
                                                                                                                        }
                                                                                                                        return 16;
                                                                                                                    }
                                                                                                                    return 17;
                                                                                                                }
                                                                                                                return 18;
                                                                                                            }
                                                                                                            return 19;
                                                                                                        }
                                                                                                        return 20;
                                                                                                    }
                                                                                                    return 21;
                                                                                                }
                                                                                                return 22;
                                                                                            }
                                                                                            return 23;
                                                                                        }
                                                                                        return 24;
                                                                                    }
                                                                                    return 25;
                                                                                }
                                                                                return 26;
                                                                            }
                                                                            return 27;
                                                                        }
                                                                        return 28;
                                                                    }
                                                                    return 29;
                                                                }
                                                                return 30;
                                                            }
                                                            return 31;
                                                        }
                                                        return 32;
                                                    }
                                                    return 33;
                                                }
                                                return 34;
                                            }
                                            return 35;
                                        }
                                        return 36;
                                    }
                                    return 37;
                                }
                                return 38;
                            }
                            return 39;
                        }
                        return 40;
                    }

                    #endregion
                    break;

                case QRCodeEncoder.ERROR_CORRECTION.Q:
                    #region Evaluacion error Alto (25%)

                    if (bits <= 13328)
                    {
                        if (bits <= 12656)
                        {
                            if (bits <= 12016)
                            {
                                if (bits <= 11408)
                                {
                                    if (bits <= 10832)
                                    {
                                        if (bits <= 10288)
                                        {
                                            if (bits <= 9848)
                                            {
                                                if (bits <= 9368)
                                                {
                                                    if (bits <= 8920)
                                                    {
                                                        if (bits <= 8264)
                                                        {
                                                            if (bits <= 7880)
                                                            {
                                                                if (bits <= 7288)
                                                                {
                                                                    if (bits <= 6968)
                                                                    {
                                                                        if (bits <= 6464)
                                                                        {
                                                                            if (bits <= 6032)
                                                                            {
                                                                                if (bits <= 5744)
                                                                                {
                                                                                    if (bits <= 5312)
                                                                                    {
                                                                                        if (bits <= 4912)
                                                                                        {
                                                                                            if (bits <= 4544)
                                                                                            {
                                                                                                if (bits <= 4096)
                                                                                                {
                                                                                                    if (bits <= 3880)
                                                                                                    {
                                                                                                        if (bits <= 3560)
                                                                                                        {
                                                                                                            if (bits <= 3176)
                                                                                                            {
                                                                                                                if (bits <= 2936)
                                                                                                                {
                                                                                                                    if (bits <= 2600)
                                                                                                                    {
                                                                                                                        if (bits <= 2360)
                                                                                                                        {
                                                                                                                            if (bits <= 2088)
                                                                                                                            {
                                                                                                                                if (bits <= 1952)
                                                                                                                                {
                                                                                                                                    if (bits <= 1648)
                                                                                                                                    {
                                                                                                                                        if (bits <= 1440)
                                                                                                                                        {
                                                                                                                                            if (bits <= 1232)
                                                                                                                                            {
                                                                                                                                                if (bits <= 1056)
                                                                                                                                                {
                                                                                                                                                    if (bits <= 880)
                                                                                                                                                    {
                                                                                                                                                        if (bits <= 704)
                                                                                                                                                        {
                                                                                                                                                            if (bits <= 608)
                                                                                                                                                            {
                                                                                                                                                                if (bits <= 496)
                                                                                                                                                                {
                                                                                                                                                                    if (bits <= 384)
                                                                                                                                                                    {
                                                                                                                                                                        if (bits <= 272)
                                                                                                                                                                        {
                                                                                                                                                                            if (bits <= 176)
                                                                                                                                                                            {
                                                                                                                                                                                if (bits <= 104)
                                                                                                                                                                                {
                                                                                                                                                                                    return 1;
                                                                                                                                                                                }
                                                                                                                                                                                return 2;
                                                                                                                                                                            }
                                                                                                                                                                            return 3;
                                                                                                                                                                        }
                                                                                                                                                                        return 4;
                                                                                                                                                                    }
                                                                                                                                                                    return 5;
                                                                                                                                                                }
                                                                                                                                                                return 6;
                                                                                                                                                            }
                                                                                                                                                            return 7;
                                                                                                                                                        }
                                                                                                                                                        return 8;
                                                                                                                                                    }
                                                                                                                                                    return 9;
                                                                                                                                                }
                                                                                                                                                return 10;
                                                                                                                                            }
                                                                                                                                            return 11;
                                                                                                                                        }
                                                                                                                                        return 12;
                                                                                                                                    }
                                                                                                                                    return 13;
                                                                                                                                }
                                                                                                                                return 14;
                                                                                                                            }
                                                                                                                            return 15;
                                                                                                                        }
                                                                                                                        return 16;
                                                                                                                    }
                                                                                                                    return 17;
                                                                                                                }
                                                                                                                return 18;
                                                                                                            }
                                                                                                            return 19;
                                                                                                        }
                                                                                                        return 20;
                                                                                                    }
                                                                                                    return 21;
                                                                                                }
                                                                                                return 22;
                                                                                            }
                                                                                            return 23;
                                                                                        }
                                                                                        return 24;
                                                                                    }
                                                                                    return 25;
                                                                                }
                                                                                return 26;
                                                                            }
                                                                            return 27;
                                                                        }
                                                                        return 28;
                                                                    }
                                                                    return 29;
                                                                }
                                                                return 30;
                                                            }
                                                            return 31;
                                                        }
                                                        return 32;
                                                    }
                                                    return 33;
                                                }
                                                return 34;
                                            }
                                            return 35;
                                        }
                                        return 36;
                                    }
                                    return 37;
                                }
                                return 38;
                            }
                            return 39;
                        }
                        return 40;
                    }

                    #endregion
                    break;

                case QRCodeEncoder.ERROR_CORRECTION.H:
                    #region Evaluacion error Muy Alto (30%)
                    if (bits <= 10208)
                    {
                        if (bits <= 9776)
                        {
                            if (bits <= 9136)
                            {
                                if (bits <= 8768)
                                {
                                    if (bits <= 8432)
                                    {
                                        if (bits <= 7888)
                                        {
                                            if (bits <= 7688)
                                            {
                                                if (bits <= 7208)
                                                {
                                                    if (bits <= 6760)
                                                    {
                                                        if (bits <= 6344)
                                                        {
                                                            if (bits <= 5960)
                                                            {
                                                                if (bits <= 5608)
                                                                {
                                                                    if (bits <= 5288)
                                                                    {
                                                                        if (bits <= 5024)
                                                                        {
                                                                            if (bits <= 4768)
                                                                            {
                                                                                if (bits <= 4304)
                                                                                {
                                                                                    if (bits <= 4112)
                                                                                    {
                                                                                        if (bits <= 3712)
                                                                                        {
                                                                                            if (bits <= 3536)
                                                                                            {
                                                                                                if (bits <= 3248)
                                                                                                {
                                                                                                    if (bits <= 3080)
                                                                                                    {
                                                                                                        if (bits <= 2728)
                                                                                                        {
                                                                                                            if (bits <= 2504)
                                                                                                            {
                                                                                                                if (bits <= 2264)
                                                                                                                {
                                                                                                                    if (bits <= 2024)
                                                                                                                    {
                                                                                                                        if (bits <= 1784)
                                                                                                                        {
                                                                                                                            if (bits <= 1576)
                                                                                                                            {
                                                                                                                                if (bits <= 1440)
                                                                                                                                {
                                                                                                                                    if (bits <= 1264)
                                                                                                                                    {
                                                                                                                                        if (bits <= 1120)
                                                                                                                                        {
                                                                                                                                            if (bits <= 976)
                                                                                                                                            {
                                                                                                                                                if (bits <= 800)
                                                                                                                                                {
                                                                                                                                                    if (bits <= 688)
                                                                                                                                                    {
                                                                                                                                                        if (bits <= 528)
                                                                                                                                                        {
                                                                                                                                                            if (bits <= 480)
                                                                                                                                                            {
                                                                                                                                                                if (bits <= 368)
                                                                                                                                                                {
                                                                                                                                                                    if (bits <= 288)
                                                                                                                                                                    {
                                                                                                                                                                        if (bits <= 208)
                                                                                                                                                                        {
                                                                                                                                                                            if (bits <= 128)
                                                                                                                                                                            {
                                                                                                                                                                                if (bits <= 72)
                                                                                                                                                                                {
                                                                                                                                                                                    return 1;
                                                                                                                                                                                }
                                                                                                                                                                                return 2;
                                                                                                                                                                            }
                                                                                                                                                                            return 3;
                                                                                                                                                                        }
                                                                                                                                                                        return 4;
                                                                                                                                                                    }
                                                                                                                                                                    return 5;
                                                                                                                                                                }
                                                                                                                                                                return 6;
                                                                                                                                                            }
                                                                                                                                                            return 7;
                                                                                                                                                        }
                                                                                                                                                        return 8;
                                                                                                                                                    }
                                                                                                                                                    return 9;
                                                                                                                                                }
                                                                                                                                                return 10;
                                                                                                                                            }
                                                                                                                                            return 11;
                                                                                                                                        }
                                                                                                                                        return 12;
                                                                                                                                    }
                                                                                                                                    return 13;
                                                                                                                                }
                                                                                                                                return 14;
                                                                                                                            }
                                                                                                                            return 15;
                                                                                                                        }
                                                                                                                        return 16;
                                                                                                                    }
                                                                                                                    return 17;
                                                                                                                }
                                                                                                                return 18;
                                                                                                            }
                                                                                                            return 19;
                                                                                                        }
                                                                                                        return 20;
                                                                                                    }
                                                                                                    return 21;
                                                                                                }
                                                                                                return 22;
                                                                                            }
                                                                                            return 23;
                                                                                        }
                                                                                        return 24;
                                                                                    }
                                                                                    return 25;
                                                                                }
                                                                                return 26;
                                                                            }
                                                                            return 27;
                                                                        }
                                                                        return 28;
                                                                    }
                                                                    return 29;
                                                                }
                                                                return 30;
                                                            }
                                                            return 31;
                                                        }
                                                        return 32;
                                                    }
                                                    return 33;
                                                }
                                                return 34;
                                            }
                                            return 35;
                                        }
                                        return 36;
                                    }
                                    return 37;
                                }
                                return 38;
                            }
                            return 39;
                        }
                        return 40;
                    }
                    #endregion
                    break;
            }

            return -1;
        }
 public virtual void AddTaskResult(ThoughtWorks.CruiseControl.Core.ITaskResult result)
 {
     this.Recordings.AddTaskResultITaskResultRecording.Called = true;
     this.Recordings.AddTaskResultITaskResultRecording.PassedITaskResultresult = result;
     if ((this.Recordings.AddTaskResultITaskResultRecording.ExceptionToThrow != null))
     {
         throw this.Recordings.AddTaskResultITaskResultRecording.ExceptionToThrow;
     }
 }
示例#9
0
 void cruiseServer_ProjectStarting(object sender, ThoughtWorks.CruiseControl.Remote.Events.CancelProjectEventArgs e)
 {
     Log("starting project " + e.ProjectName);
 }
示例#10
0
 private void CheckResponse(ThoughtWorks.CruiseControl.Remote.Messages.Response value)
 {
     if (value.Result == ThoughtWorks.CruiseControl.Remote.Messages.ResponseResult.Failure)
     {
         throw new CCNet.Core.CruiseControlException(value.ConcatenateErrors());
     }
 }
 public TextBlockFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, string path)
     : base(silvernium, path)
 {
 }
 public DataGridFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, string path, string pagerPath)
     : base(silvernium, path)
 {
     PagerPath = pagerPath;
     AssertPathPresent(pagerPath);
 }
 public DataGridFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, string path)
     : base(silvernium, path)
 {
 }
 private void CheckResponse(ThoughtWorks.CruiseControl.Remote.Messages.Response value)
 {
     if (value.Result == ThoughtWorks.CruiseControl.Remote.Messages.ResponseResult.Failure)
     {
         string message = "Request has failed on the server:" + System.Environment.NewLine +
             value.ConcatenateErrors();
         throw new CCNet.Core.CruiseControlException(message);
     }
 }
 public ComboBoxFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, string gridPath, int rowIndex, string path)
     : base(silvernium, gridPath, rowIndex, path)
 {
 }
 protected ComponentFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, string path)
 {
     Silvernium = silvernium;
     Path = path;
     AssertPathPresent(path);
 }
 public ComboBoxFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, string path)
     : base(silvernium, path)
 {
 }
 public RadioButtonFixture(ThoughtWorks.Selenium.Silvernium.Silvernium silvernium, string path)
     : base(silvernium, path)
 {
 }
 public CCTrayProject[] GetProjectList(ThoughtWorks.CruiseControl.CCTrayLib.Configuration.BuildServer server)
 {
     List<CCTrayProject> projectsList = new List<CCTrayProject>();
     projectsList.Add(new CCTrayProject(server, "Test project #1"));
     return projectsList.ToArray();
 }