private int FindChoiceArtifactId(int choiceType, string value)
        {
            int artifactId = 0;

            WholeNumberCondition choiceTypeCondition      = new WholeNumberCondition(ChoiceFieldNames.ChoiceTypeID, NumericConditionEnum.EqualTo, (int)choiceType);
            TextCondition        choiceNameCondition      = new TextCondition(ChoiceFieldNames.Name, TextConditionEnum.EqualTo, value);
            CompositeCondition   choiceCompositeCondition = new CompositeCondition(choiceTypeCondition, CompositeConditionEnum.And, choiceNameCondition);

            Query <DTOs.Choice> choiceQuery = new Query <DTOs.Choice>(new List <FieldValue>
            {
                new
                FieldValue(ArtifactQueryFieldNames.ArtifactID)
            }, choiceCompositeCondition, new List <Sort>());
            QueryResultSet <DTOs.Choice> choiceQueryResult;

            using (var client = _helper.GetServicesManager().CreateProxy <IRSAPIClient>(API.ExecutionIdentity.System))
            {
                client.APIOptions.WorkspaceID = -1;
                choiceQueryResult             = client.Repositories.Choice.Query(choiceQuery);
            }
            if (choiceQueryResult.Success && choiceQueryResult.Results.Count == 1)
            {
                artifactId = choiceQueryResult.Results.FirstOrDefault().Artifact.ArtifactID;
            }

            return(artifactId);
        }
Пример #2
0
        private static int FindChoiceArtifactId(IRSAPIClient rsapiClient, int choiceType, string value)
        {
            int artifactId = 0;

            WholeNumberCondition choiceTypeCondition                = new WholeNumberCondition(ChoiceFieldNames.ChoiceTypeID, NumericConditionEnum.EqualTo, (int)choiceType);
            TextCondition        choiceNameCondition                = new TextCondition(ChoiceFieldNames.Name, TextConditionEnum.EqualTo, value);
            CompositeCondition   choiceCompositeCondition           = new CompositeCondition(choiceTypeCondition, CompositeConditionEnum.And, choiceNameCondition);
            Query <kCura.Relativity.Client.DTOs.Choice> choiceQuery = new Query <kCura.Relativity.Client.DTOs.Choice>(
                new List <FieldValue>
            {
                new FieldValue(ArtifactQueryFieldNames.ArtifactID)
            },
                choiceCompositeCondition,
                new List <Sort>());

            try
            {
                QueryResultSet <kCura.Relativity.Client.DTOs.Choice> choiceQueryResult = rsapiClient.Repositories.Choice.Query(choiceQuery);

                if (choiceQueryResult.Success && choiceQueryResult.Results.Count == 1)
                {
                    artifactId = choiceQueryResult.Results.FirstOrDefault().Artifact.ArtifactID;
                }
                else
                {
                    Console.WriteLine("The choice could not be found.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
            return(artifactId);
        }
Пример #3
0
        public List <T> GetAllChildDTOs <T>(Guid parentFieldGuid, int parentArtifactID, ObjectFieldsDepthLevel depthLevel)
            where T : BaseDto, new()
        {
            Condition  queryCondition = new WholeNumberCondition(parentFieldGuid, NumericConditionEnum.EqualTo, parentArtifactID);
            List <RDO> objectsRdos    = GetRdos <T>(queryCondition);

            switch (depthLevel)
            {
            case ObjectFieldsDepthLevel.FirstLevelOnly:
                return(objectsRdos.Select <RDO, T>(rdo => rdo.ToHydratedDto <T>()).ToList());

            case ObjectFieldsDepthLevel.FullyRecursive:
                var allChildDtos = new List <T>();
                foreach (var childRdo in objectsRdos)
                {
                    var childDto = childRdo.ToHydratedDto <T>();

                    PopulateChildrenRecursively <T>(childDto, childRdo, depthLevel);

                    allChildDtos.Add(childDto);
                }
                return(allChildDtos);

            default:
                return(objectsRdos.Select <RDO, T>(rdo => rdo.ToHydratedDto <T>()).ToList());
            }
        }
Пример #4
0
        public static bool DeleteAllObjectsOfSpecificTypeInWorkspace(IRSAPIClient proxy, int workspaceID, int artifactTypeID)
        {
            proxy.APIOptions.WorkspaceID = workspaceID;

            //Query RDO
            WholeNumberCondition condition = new WholeNumberCondition("Artifact ID", NumericConditionEnum.IsSet);

            kCura.Relativity.Client.DTOs.Query<RDO> query = new Query<RDO>
            {
                ArtifactTypeID = artifactTypeID,
                Condition = condition
            };

            QueryResultSet<RDO> results = new QueryResultSet<RDO>();
            results = proxy.Repositories.RDO.Query(query);

            if (!results.Success)
            {
                Console.WriteLine("Error deleting the object: " + results.Message);

                for (Int32 i = 0; i <= results.Results.Count - 1; i++)
                {
                    if (!results.Results[i].Success)
                    {
                        proxy.Repositories.RDO.Delete(results.Results[i].Artifact);
                    }
                }
            }

            return true;
        }
Пример #5
0
        internal IEnumerable <T> GetAllChildDTOs <T>(int parentArtifactID, ObjectFieldsDepthLevel depthLevel)
            where T : BaseDto, new()
        {
            var parentFieldGuid = typeof(T)
                                  .GetPropertyAttributeTuples <RelativityObjectFieldParentArtifactIdAttribute>()
                                  .First().Item2.FieldGuid;

            Condition queryCondition = new WholeNumberCondition(parentFieldGuid, NumericConditionEnum.EqualTo, parentArtifactID);

            return(Query <T>(queryCondition, depthLevel));
        }
Пример #6
0
        public static kCura.Relativity.Client.DTOs.RDO RetrieveJob(IRSAPIClient connection, int artifactID)
        {
            List <kCura.Relativity.Client.DTOs.FieldValue> fields = new List <kCura.Relativity.Client.DTOs.FieldValue>();

            fields.Add(new kCura.Relativity.Client.DTOs.FieldValue(new Guid(Helper.Constant.FIELD_JOB_MISSING_FILE_INDICATOR_GUID)));
            fields.Add(new kCura.Relativity.Client.DTOs.FieldValue(new Guid(Helper.Constant.FIELD_JOB_ERROR_MESSAGE_GUID)));

            WholeNumberCondition condition = null;

            condition = new WholeNumberCondition(artifactID, NumericConditionEnum.EqualTo);

            kCura.Relativity.Client.DTOs.Query <kCura.Relativity.Client.DTOs.RDO> q = new kCura.Relativity.Client.DTOs.Query <kCura.Relativity.Client.DTOs.RDO>
            {
                ArtifactTypeGuid = new Guid(Helper.Constant.OBJECT_TYPE_FILE_VALIDATION_GUID),
                Fields           = fields
            };
            kCura.Relativity.Client.DTOs.QueryResultSet <kCura.Relativity.Client.DTOs.RDO> qrs = new kCura.Relativity.Client.DTOs.QueryResultSet <kCura.Relativity.Client.DTOs.RDO>();

            try
            {
                qrs = connection.Repositories.RDO.Query(q);
                if (qrs.Success)
                {
                    if (qrs.Results.Count == 0)
                    {
                        throw new Exception(Helper.Constant.EM_NO_CONFIGURATION);
                    }
                    else
                    {
                        return(qrs.Results[0].Artifact);
                    }
                }
                else
                {
                    throw new Exception(FormatError(qrs));
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }
Пример #7
0
        public static int FindChoiceArtifactId(IRSAPIClient proxy, int choiceType, string value)
        {
            int artifactId = 0;

            WholeNumberCondition choiceTypeCondition      = new WholeNumberCondition(ChoiceFieldNames.ChoiceTypeID, NumericConditionEnum.EqualTo, (int)choiceType);
            TextCondition        choiceNameCondition      = new TextCondition(ChoiceFieldNames.Name, TextConditionEnum.EqualTo, value);
            CompositeCondition   choiceCompositeCondition = new CompositeCondition(choiceTypeCondition, CompositeConditionEnum.And, choiceNameCondition);

            Query <Choice> choiceQuery = new Query <Choice>(new List <FieldValue>
            {
                new
                FieldValue(ArtifactQueryFieldNames.ArtifactID)
            }, choiceCompositeCondition, new List <Sort>());

            QueryResultSet <Choice> choiceQueryResult = proxy.Repositories.Choice.Query(choiceQuery);

            if (choiceQueryResult.Success && choiceQueryResult.Results.Count == 1)
            {
                artifactId = choiceQueryResult.Results.FirstOrDefault().Artifact.ArtifactID;
            }

            return(artifactId);
        }
Пример #8
0
        /// <summary>
        /// Returns all of the fields for a given object type.
        /// Does not include system fields.
        /// </summary>
        /// <param name="objMgr"></param>
        /// <param name="workspaceId"></param>
        /// <param name="objectTypeId"></param>
        /// <returns></returns>
        public static async Task <List <Field> > GetAllFieldsForObject(
            IObjectManager objMgr,
            int workspaceId,
            int objectTypeId)
        {
            var objectTypeCondition = new WholeNumberCondition(
                "Object Type Artifact Type ID",
                NumericConditionEnum.EqualTo,
                objectTypeId);

            // we want to exclude system types
            var          textCondition          = new TextCondition("Name", TextConditionEnum.Like, "System");
            NotCondition excludeSystemCondition = textCondition.Negate();

            var condition = new CompositeCondition(
                objectTypeCondition,
                CompositeConditionEnum.And,
                excludeSystemCondition);

            var queryRequest = new QueryRequest
            {
                ObjectType = new ObjectTypeRef {
                    ArtifactTypeID = FIELD_OBJ_TYPE_ID
                },
                Condition = condition.ToQueryString(),
                Fields    = new List <FieldRef>
                {
                    //new FieldRef() { Name = "Name" },
                    new FieldRef {
                        Name = "Field Type"
                    }
                },
                IncludeIDWindow          = false,
                IncludeNameInQueryResult = true
            };

            int start = 0;

            // a document shouldn't have more than 1000 fields, I would hope
            const int LENGTH = 1000;

            var retVal = new List <Field>();

            QueryResult result = await objMgr.QueryAsync(workspaceId, queryRequest, start, LENGTH);

            foreach (RelativityObject field in result.Objects)
            {
                if (!field.FieldValuePairExists("Field Type"))
                {
                    continue;  // skip
                }
                // determine the field type
                string    fieldTypeName = field.FieldValues.First().Value.ToString();
                FieldType type;
                switch (fieldTypeName)
                {
                case FieldTypes.CURRENCY:
                    type = FieldType.Currency;
                    break;

                case FieldTypes.DATE:
                    type = FieldType.Date;
                    break;

                case FieldTypes.DECIMAL:
                    type = FieldType.Decimal;
                    break;

                case FieldTypes.FILE:
                    type = FieldType.File;
                    break;

                case FieldTypes.FIXED_LENGTH_TXT:
                    type = FieldType.FixedLengthText;
                    break;

                case FieldTypes.LONG_TXT:
                    type = FieldType.LongText;
                    break;

                case FieldTypes.MULTI_CHOICE:
                    type = FieldType.MultipleChoice;
                    break;

                case FieldTypes.MULTI_OBJECT:
                    type = FieldType.MultipleObject;
                    break;

                case FieldTypes.SINGLE_CHOICE:
                    type = FieldType.SingleChoice;
                    break;

                case FieldTypes.SINGLE_OBJECT:
                    type = FieldType.SingleObject;
                    break;

                case FieldTypes.USER:
                    type = FieldType.User;
                    break;

                case FieldTypes.WHOLE_NUMBER:
                    type = FieldType.WholeNumber;
                    break;

                case FieldTypes.YES_NO:
                    type = FieldType.YesNo;
                    break;

                default:
                    type = FieldType.Empty;
                    break;
                }

                var fieldToAdd = new Field
                {
                    ArtifactID = field.ArtifactID,
                    FieldType  = type,
                    Name       = field.Name
                };
                retVal.Add(fieldToAdd);
            }

            return(retVal);
        }