Example #1
0
        private ArtifactBase AddArtifact(ArtifactType type, string name, bool selected = false, ArtifactBase parent = null)
        {
            ArtifactBase artifact;

            switch (type)
            {
            case ArtifactType.Root:
                artifact = new RootArtifact();
                break;

            case ArtifactType.Process:
                artifact = new ProcessArtifact();
                break;

            default:
                return(null);
            }
            artifact.Name       = name;
            artifact.Parent     = parent;
            artifact.IsExpanded = false;
            artifact.IsSelected = selected;
            lock (AccessLock)
            {
                _artifacts.Add(artifact);
            }
            NotifyPropertyChange("TreeItems"); // this forces the set property / INotifyPropertyCHange
            NotifyPropertyChange("Processes");
            return(artifact);
        }
Example #2
0
        public bool ArtifactCodeRuleEditing_PreTransitionCRUD(string transition)
        {
            try
            {
                switch (transition)
                {
                case "Save":

                    Guid   artifactTypeId = Guid.Parse(cbbArtifactType.SelectedItem.Value.ToString());
                    string name           = txtArtifactCodeRuleName.Text;
                    string description    = txtArtifactCodeRuleDescription.Text;

                    ArtifactType artifactType       = session.GetObjectByKey <ArtifactType>(artifactTypeId);
                    Guid         artifactCodeRuleId = ArtifactCodeRuleId;

                    ArtifactCodeRule artifactCodeRule =
                        session.GetObjectByKey <ArtifactCodeRule>(artifactCodeRuleId);
                    artifactCodeRule.ArtifactTypeId = artifactType;
                    artifactCodeRule.Description    = description;
                    artifactCodeRule.LastUpdateDate = DateTime.Now;
                    artifactCodeRule.Name           = name;
                    artifactCodeRule.Save();

                    break;

                default:
                    break;
                }
                return(true);
            }
            catch (Exception ex)
            {
                return(false);
            }
        }
Example #3
0
        public string GetArtifactCodeOfArtifactType(ArtifactTypeEnum artifactTypeEnum)
        {
            Session session          = null;
            string  artifactTypeCode = null;

            try
            {
                session          = XpoHelper.GetNewSession();
                artifactTypeCode = Enum.GetName(typeof(ArtifactTypeEnum), artifactTypeEnum);
                ArtifactType artifactType =
                    Util.getXPCollection <ArtifactType>(session, "Code", artifactTypeCode).FirstOrDefault();
                return(GetArtifactCodeOfArtifactType(artifactType.ArtifactTypeId));
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                if (session != null)
                {
                    session.Dispose();
                }
            }
        }
Example #4
0
        private bool TryGetArtifactType(string artifactTypeReferenceName, out ArtifactType artifactType)
        {
            artifactType = null;

            if (string.IsNullOrEmpty(artifactTypeReferenceName))
            {
                return(false);
            }

            bool succeeded = false;

            foreach (var supportedLinkType in m_supportedLinkTypes)
            {
                if (CQStringComparer.LinkArtifactType.Equals(supportedLinkType.Value.SourceArtifactType.ReferenceName,
                                                             artifactTypeReferenceName))
                {
                    succeeded    = true;
                    artifactType = supportedLinkType.Value.SourceArtifactType;
                    break;
                }

                if (CQStringComparer.LinkArtifactType.Equals(supportedLinkType.Value.TargetArtifactType.ReferenceName,
                                                             artifactTypeReferenceName))
                {
                    succeeded    = true;
                    artifactType = supportedLinkType.Value.TargetArtifactType;
                    break;
                }
            }

            return(succeeded);
        }
Example #5
0
        public async Task <string> CreateProofTicket(ArtifactType artifact)
        {
            var tkt = await TicketSvc.LoadJobTicketAsync(
                Config.UproduceUsername, Config.UproduceUserPassword, Document.ProofSettingsJobId.ToString());

            return(tkt);
        }
Example #6
0
        static NuGetClient()
        {
            NuGetType = ArtifactType.Register("NuGet", true, ';');

            // Workaround for dev/NuGet.Client\src\NuGet.Core\NuGet.Protocol\Plugins\PluginFactory.cs line 161:
            // FileName = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH"),
            // This line should be:
            // FileName = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") ?? "dotnet",
            //
            // Issue: https://github.com/NuGet/Home/issues/7438
            //
            Environment.SetEnvironmentVariable("DOTNET_HOST_PATH", "dotnet");
            StaticProviders = new List <Lazy <INuGetResourceProvider> >();
            StaticProviders.AddRange(Repository.Provider.GetCoreV3());
            _secretKeysLock  = new object();
            _secretAzureKeys = new Dictionary <string, string>();
            HttpHandlerResourceV3.CredentialService = new Lazy <ICredentialService>(
                () => new CredentialService(
                    providers: new AsyncLazy <IEnumerable <ICredentialProvider> >(
                        () => Task.FromResult <IEnumerable <ICredentialProvider> >(
                            new List <Creds> {
                new Creds()
            })
                        ),
                    nonInteractive: true,
                    handlesDefaultCredentials: true)
                );
        }
Example #7
0
        /// <summary>
        /// Adds the reference.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="content">The content.</param>
        /// <param name="scope">The scope.</param>
        /// <param name="mode">The mode.</param>
        /// <returns></returns>
        public Artifact AddReference(string fileName, ArtifactType content, ReferenceScope scope, string mode)
        {
            Artifact artifact = FindReference(fileName, content);

            if (artifact != null)
            {
                return(artifact);
            }

            using (Transaction transaction = this.Store.TransactionManager.BeginTransaction("Add artifact"))
            {
                artifact = new Artifact(this.Store);

                if (System.IO.Path.IsPathRooted(fileName))
                {
                    artifact.Type            = content;
                    artifact.FileName        = System.IO.Path.GetFileName(fileName);
                    artifact.InitialFileName = fileName;
                }
                else
                {
                    artifact.Type     = content;
                    artifact.FileName = fileName;
                }

                artifact.Scope             = scope;
                artifact.ConfigurationMode = mode;
                this.Artifacts.Add(artifact);

                transaction.Commit();
                return(artifact);
            }
        }
Example #8
0
 public ArtifactData()
 {
     Type     = ArtifactType.None;
     Size     = ArtifactSize.None;
     Pixels   = new List <PixelData>();
     Rotation = 0f;
 }
 internal ArtifactMarkedContentElement(int markedContentIdentifier, NameToken tag, DictionaryToken properties,
                                       string language,
                                       string actualText,
                                       string alternateDescription,
                                       string expandedForm,
                                       ArtifactType artifactType,
                                       string subType,
                                       string attributeOwners,
                                       PdfRectangle?boundingBox,
                                       IReadOnlyList <NameToken> attached,
                                       IReadOnlyList <MarkedContentElement> children,
                                       IReadOnlyList <Letter> letters,
                                       IReadOnlyList <PdfPath> paths,
                                       IReadOnlyList <IPdfImage> images,
                                       int index)
     : base(markedContentIdentifier, tag, properties, language,
            actualText,
            alternateDescription,
            expandedForm,
            true,
            children,
            letters,
            paths,
            images,
            index)
 {
     Type            = artifactType;
     SubType         = subType;
     AttributeOwners = attributeOwners;
     BoundingBox     = boundingBox;
     Attached        = attached ?? EmptyArray <NameToken> .Instance;
 }
Example #10
0
        private void CreateArtifact(IWorkspace workspace, Options options, ArtifactType artifactType)
        {
            Log.Information("Creating artifact: {Artifact}", artifactType);
            switch (artifactType)
            {
            case ArtifactType.XmlDatafiles:
                PublishXml(workspace, options);
                break;

            case ArtifactType.ZippedXmlDatafiles:
                PublishXmlZipped(workspace, options);
                break;

            case ArtifactType.Index:
                PublishIndex(workspace, options);
                break;

            case ArtifactType.ZippedIndex:
                PublishIndexZipped(workspace, options);
                break;

            case ArtifactType.RepoDistribution:
                PublishArtifactRepoDistribution(workspace, options);
                break;

            default:
                break;
            }
        }
        public void CreateMonitoringEntry(ArtifactType artifactType, string artifactName)
        {
            if (artifactName != string.Empty)
            {
                using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["authStore"].ConnectionString))
                {
                    SqlCommand command = new SqlCommand("[dbo].[bcc_MonitoringList_CreateEntry]", connection);
                    command.CommandType = CommandType.StoredProcedure;

                    SqlParameter param = new SqlParameter("@artifactType", Enum.GetName(typeof(ArtifactType), artifactType));
                    command.Parameters.Add(param);

                    param = new SqlParameter("@artifactName", artifactName);
                    command.Parameters.Add(param);

                    param = new SqlParameter("@artifactDesc", "Notify after 10 seconds.");
                    command.Parameters.Add(param);

                    param = new SqlParameter("@pollingInterval", 10);
                    command.Parameters.Add(param);

                    connection.Open();

                    command.ExecuteNonQuery();
                }
            }
        }
Example #12
0
    private static string GenerateName(ArtifactType artifactType)
    {
        string typeSynonim = "";

        switch (artifactType)
        {
        case ArtifactType.Poison:
            typeSynonim = poisonSynonims[Random.Range(0, poisonSynonims.Length)];
            break;

        case ArtifactType.Slow:
            typeSynonim = slowSynonims[Random.Range(0, slowSynonims.Length)];
            break;

        case ArtifactType.Flying:
            typeSynonim = flyingSynonims[Random.Range(0, flyingSynonims.Length)];
            break;

        case ArtifactType.Null:
            typeSynonim = nullSynonims[Random.Range(0, nullSynonims.Length)];
            break;
        }
        if (Random.Range(0, 2) == 0)
        {
            return(peopleNames[Random.Range(0, peopleNames.Length)] + "'s " + typeSynonim + " " + artifactSynonims[Random.Range(0, artifactSynonims.Length)]);
        }
        else
        {
            return(typeSynonim + " " + artifactSynonims[Random.Range(0, artifactSynonims.Length)] + " of " + peopleNames[Random.Range(0, peopleNames.Length)]);
        }
    }
Example #13
0
        public override void PlayerFinishParsing()
        {
            PlayerResolveArtifact();

            ContainerType = Prep != null ? Prep.ContainerType : (ContainerType)(-1);

            if (gDobjArtifact != null)
            {
                gCommandParser.ObjData = gCommandParser.IobjData;

                gCommandParser.ObjData.QueryDescFunc = () => string.Format("{0}Put {1} {2} what? ", Environment.NewLine, gDobjArtifact.EvalPlural("it", "them"), Enum.IsDefined(typeof(ContainerType), ContainerType) ? gEngine.EvalContainerType(ContainerType, "inside", "on", "under", "behind") : "in");

                PlayerResolveArtifact();

                if (gIobjArtifact != null)
                {
                    if (!Enum.IsDefined(typeof(ContainerType), ContainerType))
                    {
                        var artTypes = new ArtifactType[] { ArtifactType.InContainer, ArtifactType.OnContainer };

                        var defaultAc = gIobjArtifact.GetArtifactCategory(artTypes);

                        ContainerType = defaultAc != null?gEngine.GetContainerType(defaultAc.Type) : ContainerType.In;
                    }
                }
            }
        }
Example #14
0
        static PackageDBTests()
        {
            T0 = ArtifactType.Register("T0", true);
            T1 = ArtifactType.Register("T1", true, ';');
            T2 = ArtifactType.Register("T2", true, ',');

            PLevel0V1 = Create(SVersion.Parse("1.0.0"));
            PLevel0V2 = Create(SVersion.Parse("2.0.0"));
            PLevel0V3 = Create(SVersion.Parse("3.0.0"));
            PLevel0V4 = Create(SVersion.Parse("4.0.0"));
            PLevel0   = new PackageInfo[][] { PLevel0V1, PLevel0V2, PLevel0V3, PLevel0V4 };
            PackageInfo[] Create(SVersion v)
            {
                var result = new PackageInfo[60];

                for (int i = 0; i < result.Length; ++i)
                {
                    var type = i < (result.Length / 3)
                                ? T0
                                : i < (2 * result.Length / 3)
                                    ? T1
                                    : T2;
                    var p = new PackageInfo();
                    p.Key = new ArtifactInstance(type, $"P{i}", v);
                    p.FeedNames.Add($"F{i / (result.Length / 10)}");
                    result[i] = p;
                }
                return(result);
            }
        }
Example #15
0
        public virtual bool IsAttackable01(ref IArtifactCategory ac)
        {
            var artTypes = new ArtifactType[] { ArtifactType.DeadBody, ArtifactType.DisguisedMonster, ArtifactType.InContainer, ArtifactType.DoorGate };

            ac = GetArtifactCategory(artTypes, false);

            return(!Globals.IsRulesetVersion(5) && ac != null);
        }
Example #16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ParseException"/> class.
 /// </summary>
 /// <param name="innerException">The inner exception.</param>
 /// <param name="action">The action.</param>
 /// <param name="isQuery">if set to <c>true</c> [is query].</param>
 /// <param name="artifact">The artifact.</param>
 /// <param name="args">The arguments.</param>
 public ParseException(
     Exception innerException, DatasetActionEnumType action, bool isQuery, ArtifactType artifact, params object[] args)
     : base(innerException, null, null, args)
 {
     this._action = action;
     this._isQuery = isQuery;
     this._artifact = artifact;
 }
Example #17
0
        public virtual bool IsAttackable()
        {
            var artTypes = new ArtifactType[] { ArtifactType.DeadBody, ArtifactType.DisguisedMonster, ArtifactType.InContainer, ArtifactType.DoorGate };

            var ac = GetArtifactCategory(artTypes);

            return(ac != null && (ac.Type == ArtifactType.DeadBody || ac.Type == ArtifactType.DisguisedMonster || ac.GetBreakageStrength() >= 1000));
        }
 public ArtifactInfo(IDataRecord record)
 {
     type          = record.GetValue <ArtifactType>("id");
     goalRange     = record.GetValue <int>("goalrange");
     npcPresenceId = record.GetValue <int?>("npcpresenceid");
     isPersistent  = record.GetValue <bool>("persistent");
     minimumLoot   = record.GetValue <int>("minimumloot");
 }
Example #19
0
 public Artifact(ArtifactType artifactType)
 {
     ArtifactType = artifactType;
     Name         = GenerateName(artifactType);
     Value        = GenerateValue(artifactType);
     Color        = new Color(Random.Range(0.5f, 1f), Random.Range(0.5f, 1f), Random.Range(0.5f, 1f));
     Sprite       = GetSpriteByArtifactType(ArtifactType);
 }
Example #20
0
 protected TfsArtifactHandlerBase(ArtifactType handledArtifactType)
 {
     if (null == handledArtifactType)
     {
         throw new ArgumentNullException("handledArtifactType");
     }
     m_handledArtifactType = handledArtifactType;
 }
Example #21
0
        protected bool CanHandleArtifactType(ArtifactType artifactType)
        {
            if (null == artifactType)
            {
                return(false);
            }

            return(CQStringComparer.LinkArtifactType.Equals(artifactType.ReferenceName, m_handledArtifactType.ReferenceName));
        }
        protected override Artifact Create(ArtifactType type)
        {
            if (type == ArtifactType.Actions_Storage)
            {
                return(new ActionsStorageArtifact());
            }

            return(null);
        }
Example #23
0
        protected override CreateArtifactParameters Create(ArtifactType type)
        {
            if (type == ArtifactType.Actions_Storage)
            {
                return(new CreateActionsStorageArtifactParameters());
            }

            return(null);
        }
Example #24
0
 public Artifact(ArtifactType type, ArtifactRarity rarity, string name, string desc, float amount, Sprite sprite)
 {
     this.type           = type;
     this.name           = name;
     this.artifactRarity = rarity;
     this.description    = desc;
     this.amount         = amount;
     this.sprite         = sprite;
 }
Example #25
0
        public Artifact(Vector2 position, float layer, float size, ArtifactType type, bool found)
        {
            this.position = position;
            this.layer    = layer;
            this.size     = size;
            this.type     = type;
            this.found    = found;

            //Init();
        }
 public ArtifactMonitoringEventArgs(ArtifactType artifactType, string artifactName, string receiveLocationName, string artifactURL, string serverName, string hostName, string artifactStatus)
 {
     this.artifactName = artifactName;
     this.receiveLocationName = receiveLocationName;
     this.artifactURL = artifactURL;
     this.serverName = serverName;
     this.hostName = hostName;
     this.artifactStatus = artifactStatus;
     this.artifactType = artifactType;
 }
Example #27
0
        public override bool TryCreateArtifactFromId(ArtifactType artifactType, string id, out IArtifact artifact)
        {
            if (!base.TryCreateArtifactFromId(artifactType, id, out artifact))
            {
                return(false);
            }

            artifact = new Toolkit.Linking.Artifact(id, m_handledArtifactType);
            return(true);
        }
        public override bool TryCreateArtifactFromId(ArtifactType artifactType, string id, out IArtifact artifact)
        {
            if (!base.TryCreateArtifactFromId(artifactType, id, out artifact))
            {
                return(false);
            }

            artifact = new Toolkit.Linking.Artifact(LinkingConstants.VcRevisionFilePrefix + id, m_handledArtifactType);
            return(true);
        }
Example #29
0
 void IUtf8JsonSerializable.Write(Utf8JsonWriter writer)
 {
     writer.WriteStartObject();
     writer.WritePropertyName("name");
     writer.WriteStringValue(Name.ToString());
     writer.WritePropertyName("uri");
     writer.WriteStringValue(Uri.AbsoluteUri);
     writer.WritePropertyName("type");
     writer.WriteStringValue(ArtifactType.ToSerialString());
     writer.WriteEndObject();
 }
        int HandleArtifactOfType(ArtifactType artifactType, BoundedContextTopology boundedContextConfiguration, MutableAritfactsDictionary artifactsDictionary, List <string> nonMatchingArtifacts)
        {
            var targetProperty = artifactType.TargetPropertyExpression.GetPropertyInfo();

            var newArtifacts = 0;
            var artifacts    = _artifacts.Where(_ => artifactType.Type.IsAssignableFrom(_));

            foreach (var artifact in artifacts)
            {
                var feature = boundedContextConfiguration.FindMatchingFeature(artifact.Namespace, nonMatchingArtifacts);
                if (feature.Value != null)
                {
                    MutableArtifactsByTypeDictionary artifactsByType;
                    if (!artifactsDictionary.TryGetValue(feature.Key, out artifactsByType))
                    {
                        artifactsByType = artifactsDictionary[feature.Key] = new Dictionary <PropertyInfo, Dictionary <ArtifactId, ArtifactDefinition> >();
                    }

                    Dictionary <ArtifactId, ArtifactDefinition> mutableArtifacts;
                    if (!artifactsByType.TryGetValue(targetProperty, out mutableArtifacts))
                    {
                        mutableArtifacts = artifactsByType[targetProperty] = new Dictionary <ArtifactId, ArtifactDefinition>();
                    }

                    if (!mutableArtifacts.Any(_ => _.Value.Type.GetActualType() == artifact))
                    {
                        var artifactObject = new Dolittle.Artifacts.Artifact(ArtifactId.New(), ArtifactGeneration.First);
                        if (artifact.HasAttribute <ArtifactAttribute>())
                        {
                            artifactObject = (artifact.GetTypeInfo().GetCustomAttributes(typeof(ArtifactAttribute), false).First() as ArtifactAttribute).Artifact;
                        }

                        AddNewArtifact(artifactObject, artifact, mutableArtifacts, artifactType.TypeName);
                        newArtifacts++;
                    }
                    else
                    {
                        if (artifact.HasAttribute <ArtifactAttribute>())
                        {
                            var artifactObject = (artifact.GetTypeInfo().GetCustomAttributes(typeof(ArtifactAttribute), false).First() as ArtifactAttribute).Artifact;

                            var existingArtifact = mutableArtifacts.Single(_ => _.Value.Type.GetActualType() == artifact);
                            if (!existingArtifact.Key.Value.Equals(artifactObject.Id.Value))
                            {
                                mutableArtifacts.Remove(existingArtifact.Key);
                                AddNewArtifact(artifactObject, artifact, mutableArtifacts, artifactType.TypeName);
                                newArtifacts++;
                            }
                        }
                    }
                }
            }
            return(newArtifacts);
        }
Example #31
0
 bool InventoryContains(ArtifactType type)
 {
     foreach (var artifact in inventory)
     {
         if (artifact.type == type)
         {
             return(true);
         }
     }
     return(false);
 }
Example #32
0
        public static bool EnsureValidPath(ArtifactType artifactType, string path, out string error)
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                error = $"Path must be defined for type='{artifactType}'";
                return(false);
            }

            error = null;
            return(true);
        }
Example #33
0
 public override int GetHashCode()
 {
     unchecked
     {
         int hashCode = base.GetHashCode();
         hashCode = (hashCode * 397) ^ (int)GenerateActionType;
         hashCode = (hashCode * 397) ^ ChildCount.GetHashCode();
         hashCode = (hashCode * 397) ^ (ArtifactType != null ? ArtifactType.GetHashCode() : 0);
         hashCode = (hashCode * 397) ^ ArtifactTypeId.GetHashCode();
         return(hashCode);
     }
 }
        public List<BCCMonitoringReportEntry> MonitoringDataReport(ArtifactType artifactType, string artifactName, DateTime startDate, DateTime endDate)
        {
            List<BCCMonitoringReportEntry> list = null;

            using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["authStore"].ConnectionString))
            {
                SqlCommand command = new SqlCommand("[dbo].[bcc_MonitoringListData_Report]", connection);
                command.CommandType = CommandType.StoredProcedure;

                SqlParameter param = new SqlParameter("@artifactType", Enum.GetName(typeof(ArtifactType), artifactType));
                command.Parameters.Add(param);

                param = new SqlParameter("@artifactName", artifactName);
                command.Parameters.Add(param);

                param = new SqlParameter("@startDate", startDate);
                command.Parameters.Add(param);

                param = new SqlParameter("@endDate", endDate);
                command.Parameters.Add(param);

                connection.Open();

                SqlDataReader reader = command.ExecuteReader(CommandBehavior.CloseConnection);

                list = new List<BCCMonitoringReportEntry>();

                BCCMonitoringReportEntry entry = null;

                while (reader.Read())
                {
                    // Create a new list at every instance.
                    entry = new BCCMonitoringReportEntry();
                    entry.ArtifactType = (ArtifactType)Enum.Parse(typeof(ArtifactType), (string)reader[0]);

                    entry.ArtifactName = (string)reader[1];

                    entry.ArtifactStatus = (string)reader[2];

                    entry.ReportedDate = (DateTime) reader[3];

                    list.Add(entry);
                }

            }

            return list;
        }
        public void LogMonitoringData(ArtifactType artifactType, string artifactName, string status)
        {
            using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["authStore"].ConnectionString))
            {
                SqlCommand command = new SqlCommand("[dbo].[bcc_MonitoringListData_Insert]", connection);
                command.CommandType = CommandType.StoredProcedure;

                SqlParameter param = new SqlParameter("@artifactType", Enum.GetName(typeof(ArtifactType), artifactType));
                command.Parameters.Add(param);

                param = new SqlParameter("@artifactName", artifactName);
                command.Parameters.Add(param);

                param = new SqlParameter("@status", status);
                command.Parameters.Add(param);

                connection.Open();
                command.ExecuteNonQuery();
            }
        }
Example #36
0
 public IvyArtifact(string filename, ArtifactType type)
 {
     this.Name = Path.GetFileNameWithoutExtension(filename);
     this.Extension = Path.GetExtension(filename);
     this.Type = type;
 }
 public BCCMonitoringEntry(string artifactName, ArtifactType artifactType, int pollingInterval, bool isEnabled, bool isMarkedForDelete)
 {
     this.artifactName = artifactName;
     this.artifactType = artifactType;
     this.pollingInterval = pollingInterval;
     this.isEnabled = isEnabled;
     this.isMarkedForDelete = isMarkedForDelete;
 }
 /// <summary>
 /// Creates a artifact type query string parameter.
 /// </summary>
 /// <param name="type">The value to use in the artifact type query string parameter. See remarks.</param>
 /// <returns>A artifact type query string parameter.</returns>
 /// <remarks>
 /// This could be used, for example, to specify the type of an artifact.
 /// </remarks>
 public static QueryParameter ArtifactType(ArtifactType type)
 {
     return new QueryParameter(true, TYPE, XmlQNameEnumUtil.GetNameValue(type));
 }
        public void MonitoringEntryMarkedForDeletion(ArtifactType artifactType, string artifactName)
        {
            using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["authStore"].ConnectionString))
            {
                SqlCommand command = new SqlCommand("[dbo].[bcc_MonitoringList_MarkedForDelete]", connection);
                command.CommandType = CommandType.StoredProcedure;

                SqlParameter param = new SqlParameter("@artifactType", Enum.GetName(typeof(ArtifactType), artifactType));
                command.Parameters.Add(param);

                param = new SqlParameter("@artifactName", artifactName);
                command.Parameters.Add(param);

                connection.Open();

                command.ExecuteNonQuery();
            }
        }
 /// <summary>
 /// Use to monitor various BizTalk Artifacts
 /// </summary>
 /// <param name="artifactType"></param>
 /// <param name="artifactName"></param>
 /// <param name="pollIntervalInSecs"></param>
 public BCCMonitoring(ArtifactType artifactType, string artifactName, int pollIntervalInSecs)
 {
     this.artifactType = artifactType;
     this.artifactName = artifactName;
     this.pollIntervalInSecs = pollIntervalInSecs;
 }