Exemplo n.º 1
0
    private int DestroySearchResults(ObjectSearchResults objectSearchResults)
    {
      foreach (ObjectVersion objectVersion in objectSearchResults)
        DestroyObject(objectVersion);

      return objectSearchResults.Count;
    }
        private void btn_Search_Click(object sender, EventArgs e)
        {
            var searchForm = new SearchForm();
            var result     = searchForm.ShowDialog();

            if (result == DialogResult.OK)
            {
                var searchTerm = searchForm.SearchTerm;

                ObjectSearchResults objects = null;

                switch (searchForm.SearchType)
                {
                case Enums.SearchType.Filedata:
                    objects = VaultOperations.LoggedInVault.ObjectSearchOperations.SearchForObjectsByString(searchTerm, false, MFilesAPI.MFFullTextSearchFlags.MFFullTextSearchFlagsLookInFileData);
                    break;

                case Enums.SearchType.Metadata:
                    objects = VaultOperations.LoggedInVault.ObjectSearchOperations.SearchForObjectsByString(searchTerm, false, MFilesAPI.MFFullTextSearchFlags.MFFullTextSearchFlagsLookInMetaData);
                    break;

                case Enums.SearchType.FileAndMetadata:
                    objects = VaultOperations.LoggedInVault.ObjectSearchOperations.SearchForObjectsByString(searchTerm, false, MFilesAPI.MFFullTextSearchFlags.MFFullTextSearchFlagsLookInFileData | MFFullTextSearchFlags.MFFullTextSearchFlagsLookInMetaData);
                    break;

                default:
                    objects = VaultOperations.LoggedInVault.ObjectSearchOperations.SearchForObjectsByString(searchTerm, false, MFilesAPI.MFFullTextSearchFlags.MFFullTextSearchFlagsLookInFileData | MFFullTextSearchFlags.MFFullTextSearchFlagsLookInMetaData);
                    break;
                }

                var searchResultsView = new SearchResultForm(objects);
                searchResultsView.ShowDialog();
            }
        }
        private int DestroySearchResults(ObjectSearchResults objectSearchResults)
        {
            foreach (ObjectVersion objectVersion in objectSearchResults)
            {
                DestroyObject(objectVersion);
            }

            return(objectSearchResults.Count);
        }
Exemplo n.º 4
0
        private static void ProcessData(string vaultName, Vault vault, IView view, DateTime startDate,
                                        IProcessor processor)
        {
            Thread.CurrentThread.Name = $"Thread-{vaultName}";


            var conditions = view.SearchConditions;
            var dfDate     = new DataFunctionCall();

            dfDate.SetDataDate();

            var search     = new SearchCondition();
            var expression = new Expression();
            var value      = new TypedValue();

            expression.SetPropertyValueExpression((int)MFBuiltInPropertyDef.MFBuiltInPropertyDefLastModified,
                                                  MFParentChildBehavior.MFParentChildBehaviorNone, dfDate);
            search.Set(expression, MFConditionType.MFConditionTypeGreaterThanOrEqual, value);

            conditions.Add(-1, search);

            search     = new SearchCondition();
            expression = new Expression();
            value      = new TypedValue();
            expression.SetPropertyValueExpression((int)MFBuiltInPropertyDef.MFBuiltInPropertyDefLastModified,
                                                  MFParentChildBehavior.MFParentChildBehaviorNone, dfDate);
            search.Set(expression, MFConditionType.MFConditionTypeLessThan, value);

            conditions.Add(-1, search);


            var currentDateTime = startDate;

            var processorContext = processor.CreateContext();

            while (currentDateTime < DateTime.Now)
            {
                conditions[conditions.Count - 1].TypedValue.SetValue(MFDataType.MFDatatypeDate, currentDateTime);
                currentDateTime = currentDateTime.AddMonths(1);
                conditions[conditions.Count].TypedValue.SetValue(MFDataType.MFDatatypeDate, currentDateTime);


                ObjectSearchResults objects = vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(conditions,
                                                                                                          MFSearchFlags.MFSearchFlagReturnLatestVisibleVersion, false, 0);

                foreach (ObjectVersion objVer in objects)
                {
                    processorContext.ProcessObject(new ObjectVersionWrapper(objVer, vault, vaultName));
                }
                //internalDocuments.AddRange(from ObjectVersion obj in objects
                //                            select new MFilesInternalDocument(internalVault, obj));
            }
        }
        public static List <T> ConvertToOTObjects <T>(this ObjectSearchResults objectSearchResults, Vault vault)
            where T : IObjVerEx, new()
        {
            List <T> result = new List <T>();

            if (objectSearchResults != null && objectSearchResults.Count > 0)
            {
                IEnumerator searchResultObjVerEnum = objectSearchResults.GetAsObjectVersions().GetEnumerator();
                while (searchResultObjVerEnum.MoveNext())
                {
                    result.Add(new T()
                    {
                        objVerEx = new ObjVerEx(vault, (ObjectVersion)searchResultObjVerEnum.Current)
                    });
                }
            }
            return(result);
        }
        public static List <ObjVerEx> SearchByPropertyDef <T>(ObjVerEx objVerEx, int property_def, T?value)
            where T : struct
        {
            SearchConditions searchConditions = new SearchConditions();

            SearchCondition searchCondition;

            searchCondition = new SearchCondition();
            searchCondition.Expression.SetPropertyValueExpression(property_def, MFParentChildBehavior.MFParentChildBehaviorNone);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeLookup, value);
            searchConditions.Add(-1, searchCondition);

            searchCondition = new SearchCondition();
            searchCondition.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeDeleted);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, false);
            searchConditions.Add(-1, searchCondition);

            ObjectSearchResults objectSearchResults =
                objVerEx.Vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(searchConditions, MFSearchFlags.MFSearchFlagNone, false);

            List <ObjVerEx> searchedOT = null;

            if (objectSearchResults != null && objectSearchResults.Count > 0)
            {
                searchedOT = new List <ObjVerEx>();
                IEnumerator   searchResultObjVerEnum = objectSearchResults.GetAsObjectVersions().GetEnumerator();
                ObjectVersion objectVersion          = null;
                while (searchResultObjVerEnum.MoveNext())
                {
                    objectVersion = (ObjectVersion)searchResultObjVerEnum.Current;
                    ObjectVersionAndProperties objVerAndProps =
                        objVerEx.Vault.ObjectOperations.GetLatestObjectVersionAndProperties(objectVersion.ObjVer.ObjID, true);
                    ObjVerEx item = new ObjVerEx(objVerEx.Vault, objVerAndProps);
                    searchedOT.Add(item);
                }
            }
            return(searchedOT);
        }
        public static List <T> getAll <T>(Vault vault, int typeId, bool includeDeleted, int searchResultsCount)
            where T : IObjVerEx, new()
        {
            ObjectSearchResults objSearchResults = vault.getAllSearchResults(typeId, includeDeleted, searchResultsCount);

            if (objSearchResults == null || objSearchResults.Count == 0)
            {
                return(new List <T>());
            }

            List <T> allItems = new List <T>();

            foreach (ObjectVersion objectVersion in objSearchResults.GetAsObjectVersions())
            {
                T item = new T()
                {
                    objVerEx = new ObjVerEx(vault, objectVersion.ObjVer)
                };
                allItems.Add(item);
            }
            return(allItems);
        }
Exemplo n.º 8
0
        private static int GetPreviewsWorkFlowNum(Vault vault, int flowNumberId, ObjectSearchResults count)
        {
            var num = 0;

            foreach (ObjectVersion ov in count)
            {
                var objVer = ov.ObjVer;
                var pvs    = vault.ObjectPropertyOperations.GetProperties(objVer);
                var pv     = pvs.SearchForPropertyEx(flowNumberId, true);
                if (pv != null && !pv.Value.IsNULL())
                {
                    var flowNumberString = pv.GetValueAsLocalizedText();
                    var tempFlowStr      = GetFlowNumberFromObject(flowNumberString).TrimStart('0');
                    var number           = Int32.Parse(tempFlowStr);
                    if (number > num)
                    {
                        num = number;
                    }
                }
            }
            return(num);
        }
Exemplo n.º 9
0
        public void Search()
        {
            Assembly current = Assembly.GetAssembly(typeof(Tools));
            Stream   stream  = current.GetManifestResourceStream(typeof(Tools), "VaultStructure.json");

            if (stream == null)
            {
                Assert.Fail("Failed to load stream.");
            }

            TestVault vault = TestVault.FromStream(stream);

            PropertyValues pvs = new PropertyValues();
            PropertyValue  pv  = new PropertyValue {
                PropertyDef = (int)MFBuiltInPropertyDef.MFBuiltInPropertyDefClass
            };

            pv.TypedValue.SetValue(MFDataType.MFDatatypeLookup, 0);
            pvs.Add(-1, pv);
            vault.ObjectOperations.CreateNewObject(0, pvs);

            Assert.AreEqual(1, vault.ovaps.Count, "Number of objects != 1");
            const int testPropID = 55;

            pv = new PropertyValue {
                PropertyDef = testPropID
            };
            const int testLookupID = 77;
            Lookups   lks          = new Lookups();
            Lookup    lk           = new Lookup {
                Item = testLookupID, ObjectType = 0
            };

            lks.Add(-1, lk);
            pv.TypedValue.SetValueToMultiSelectLookup(lks);
            pvs.Add(-1, pv);
            vault.ObjectOperations.CreateNewObject(0, pvs);
            Assert.AreEqual(2, vault.ovaps.Count, "Original does not have 2 objects");

            SearchCondition c = new SearchCondition();

            c.Expression.DataPropertyValuePropertyDef = testPropID;
            c.ConditionType = MFConditionType.MFConditionTypeEqual;
            c.TypedValue.SetValue(MFDataType.MFDatatypeLookup, testLookupID);

            SearchCondition sc = new SearchCondition();

            sc.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeDeleted);
            sc.ConditionType = MFConditionType.MFConditionTypeEqual;
            sc.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, false);

            SearchConditions search = new SearchConditions();

            search.Add(-1, sc);
            search.Add(-1, c);

            ObjectSearchResults results = vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(search,
                                                                                                      MFSearchFlags.MFSearchFlagDisableRelevancyRanking, false);

            Assert.AreEqual(1, results.Count);

            ObjectVersion ov = results[1];

            Assert.NotNull(ov);

            ObjectVersions ovs = results.GetAsObjectVersions();

            foreach (ObjectVersion result in ovs)
            {
                Assert.NotNull(result);
            }

            vault.ObjectOperations.CreateNewObject(2, pvs);
            results = vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(search,
                                                                                  MFSearchFlags.MFSearchFlagDisableRelevancyRanking, false);
            Assert.AreEqual(2, results.Count);

            sc = new SearchCondition();
            sc.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeObjectTypeID);
            sc.ConditionType = MFConditionType.MFConditionTypeEqual;
            sc.TypedValue.SetValue(MFDataType.MFDatatypeLookup, 0);
            search.Add(-1, sc);

            results = vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(search,
                                                                                  MFSearchFlags.MFSearchFlagDisableRelevancyRanking, false);
            Assert.AreEqual(1, results.Count);
        }
 public SearchResultForm(ObjectSearchResults searchResults)
 {
     InitializeComponent();
     _searchResults = searchResults ?? null;
 }
        public static List <T> search_property_definition <T, T2>(this IObjVerEx obj, int propertyDefinitionID, T2 value, int propertyDefinition2ID, IObjVerEx value2, int propertyDefinition3ID, IObjVerEx value3, bool includeDeleted = false)
            where T : IObjVerEx, new()
        {
            SearchCondition  searchCondition;
            SearchConditions searchConditions = new SearchConditions();

            Type   t = typeof(T);
            object o = Activator.CreateInstance <T>();

            FieldInfo[] fields = t.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
            int         oid    = -1;

            foreach (FieldInfo f in fields)
            {
                if (f.Name == "TypeID")
                {
                    oid = Convert.ToInt32(f.GetValue(o));
                }
            }

            searchCondition = new SearchCondition();
            searchCondition.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeObjectTypeID);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeLookup, oid);
            searchConditions.Add(-1, searchCondition);

            searchCondition = new SearchCondition();
            searchCondition.Expression.SetPropertyValueExpression(propertyDefinitionID, MFParentChildBehavior.MFParentChildBehaviorNone);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeText, value);
            searchConditions.Add(-1, searchCondition);

            searchCondition = new SearchCondition();
            searchCondition.Expression.SetPropertyValueExpression(propertyDefinition2ID, MFParentChildBehavior.MFParentChildBehaviorNone);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeLookup, value2.objVerEx.ToLookup());
            searchConditions.Add(-1, searchCondition);

            searchCondition = new SearchCondition();
            searchCondition.Expression.SetPropertyValueExpression(propertyDefinition3ID, MFParentChildBehavior.MFParentChildBehaviorNone);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeLookup, value3.objVerEx.ToLookup());
            searchConditions.Add(-1, searchCondition);

            if (!includeDeleted)
            {
                searchCondition = new SearchCondition();
                searchCondition.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeDeleted);
                searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
                searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, false);
                searchConditions.Add(-1, searchCondition);
            }

            ObjectSearchResults objectSearchResults =
                obj.objVerEx.Vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(searchConditions, MFSearchFlags.MFSearchFlagNone, false);

            List <T> searchedOT = new List <T>();

            if (objectSearchResults != null && objectSearchResults.Count > 0)
            {
                IEnumerator   searchResultObjVerEnum = objectSearchResults.GetAsObjectVersions().GetEnumerator();
                ObjectVersion objectVersion          = null;
                while (searchResultObjVerEnum.MoveNext())
                {
                    objectVersion = (ObjectVersion)searchResultObjVerEnum.Current;
                    ObjectVersionAndProperties objVerAndProps =
                        obj.objVerEx.Vault.ObjectOperations.GetLatestObjectVersionAndProperties(objectVersion.ObjVer.ObjID, true);
                    T item = new T()
                    {
                        objVerEx = new ObjVerEx(obj.objVerEx.Vault, objVerAndProps)
                    };
                    searchedOT.Add(item);
                }
            }
            return(searchedOT);
        }
        public static T search <T>(Vault vault, int objTypeId, int objOrExtObjId, bool includeDeleted)
            where T : IObjVerEx, new()
        {
            SearchConditions searchConditions = new SearchConditions();
            SearchCondition  searchCondition  = new SearchCondition();

            // Object type id condition
            searchCondition.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeObjectTypeID);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeLookup, objTypeId);
            searchConditions.Add(1, searchCondition);

            // External objects condition
            searchCondition = new SearchCondition();
            searchCondition.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeExtID);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeText, objOrExtObjId);
            searchConditions.Add(2, searchCondition);

            // Include deleted objects condition
            searchCondition = new SearchCondition();
            searchCondition.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeDeleted);
            searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
            searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, includeDeleted);
            searchConditions.Add(3, searchCondition);

            // Search for external objects
            ObjectSearchResults objSearchResults =
                vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(
                    searchConditions, MFSearchFlags.MFSearchFlagNone, false);

            ObjectVersionAndProperties objVerAndProps = null;

            if (objSearchResults != null && objSearchResults.Count > 0)
            {
                IEnumerator   searchResultObjVerEnum = objSearchResults.GetAsObjectVersions().GetEnumerator();
                ObjectVersion objectVersion          = null;
                searchResultObjVerEnum.MoveNext();
                objectVersion  = (ObjectVersion)searchResultObjVerEnum.Current;
                objVerAndProps = vault.ObjectOperations.GetLatestObjectVersionAndProperties(objectVersion.ObjVer.ObjID, false);
                return(new T()
                {
                    objVerEx = new ObjVerEx(vault, objVerAndProps)
                });
            }
            else
            {
                // Non-external objects condition
                searchCondition = new SearchCondition();
                searchCondition.Expression.SetStatusValueExpression(MFStatusType.MFStatusTypeObjectID);
                searchCondition.ConditionType = MFConditionType.MFConditionTypeEqual;
                searchCondition.TypedValue.SetValue(MFDataType.MFDatatypeInteger, objOrExtObjId);
                searchConditions.Add(2, searchCondition);

                // Search for non-external objects
                objSearchResults =
                    vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(
                        searchConditions, MFSearchFlags.MFSearchFlagNone, false);

                if (objSearchResults != null && objSearchResults.Count > 0)
                {
                    IEnumerator   searchResultObjVerEnum = objSearchResults.GetAsObjectVersions().GetEnumerator();
                    ObjectVersion objectVersion          = null;
                    searchResultObjVerEnum.MoveNext();
                    objectVersion  = (ObjectVersion)searchResultObjVerEnum.Current;
                    objVerAndProps = vault.ObjectOperations.GetLatestObjectVersionAndProperties(objectVersion.ObjVer.ObjID, false);
                    return(new T()
                    {
                        objVerEx = new ObjVerEx(vault, objVerAndProps)
                    });
                }
                else
                {
                    return(default(T));
                }
            }
        }