public static bool IsFlagsSet(ObjectAccessId accessObject, RightsFlags[] flags,SetType setType=SetType.Any)
 {
     if (LoggedUser == null)
         throw new Exception("Invalid user!");
     if (LoggedUser.IsAdmin)
         return true;
     switch (setType)
     {
         case SetType.All:
             if (flags.Select(flag => IsFlagSet(accessObject, flag)).All(result => result))
             {
                 return true;
             }
             break;
         case SetType.Any:
             if (flags.Select(flag => IsFlagSet(accessObject, flag)).Any(result => result))
             {
                 return true;
             }
             break;
         default:
             throw new ArgumentOutOfRangeException("setType");
     }
     return false;
 }

        /* LOGIC
         * 1. Randomly select one node in the graph.
         * 2. Randonly select the second node from the first node's connections.
         * 3. Compute all the features for this pair of connected nodes.
         * 4. Randomly select one node from the nodes that are not connected to
         *    the first node.
         * 5. Compute all the features for the selected pair of disconnected nodes.
         * 6. Repeat 5000 times.
         * Note: when selecting a pair, make sure that it is not already in the training set.
         */
        public static void CreateTrainingAndTestSets(string pathDataDir, SetType trainingSetType, SetType testingSetType,
                                                     int trainingSetSize, int testingSetSize, int testingDataAmount)
        {
            Console.WriteLine("Starting creation of training and testing subsets . . .");
            FeaturesExtractor featuresExtractor = new FeaturesExtractor(pathDataDir);
            featuresExtractor.LoadCharacterCharactersData();
            featuresExtractor.LoadCharacterComicsData();
            featuresExtractor.LoadCharacterSeriesData();
            HashSet<string> usedExamples = new HashSet<string>();
            HashSet<string> usedNodes = new HashSet<string>();

            // Training data
            Console.WriteLine("Creating training subset . . .");
            Console.WriteLine(String.Format("Training set type: {0}", trainingSetType));
            switch (trainingSetType)
            {
                case SetType.Balanced:
                    CreateAndSaveRandomBalancedSubset(FileManager.GetPathResultTrainingSet(pathDataDir, trainingSetType),
                                                      featuresExtractor, usedExamples, usedNodes, trainingSetSize);
                    break;
                case SetType.Proportional:
                    CreateAndSaveRandomProportionalSubset(FileManager.GetPathResultTrainingSet(pathDataDir, trainingSetType),
                                                          featuresExtractor, usedExamples, usedNodes, trainingSetSize);
                    break;
            }

            // Testing data
            Console.WriteLine("Creating testing subset . . .");
            Console.WriteLine(String.Format("Testing set type: {0}", testingSetType));
            switch (testingSetType)
            {
                case SetType.Balanced:
                    CreateAndSaveRandomBalancedSubset(FileManager.GetPathResultTestSet(pathDataDir, testingSetType),
                                                      featuresExtractor, usedExamples, usedNodes, testingSetSize);
                    break;
                case SetType.Proportional:
                    CreateAndSaveRandomProportionalSubset(FileManager.GetPathResultTestSet(pathDataDir, testingSetType),
                                                          featuresExtractor, usedExamples, usedNodes, testingSetSize);
                    break;
                case SetType.Nodes:
                    CreateAndSaveRandomNodesSubset(FileManager.GetPathResultTestSet(pathDataDir, testingSetType),
                                                   featuresExtractor, usedNodes, testingSetSize, testingDataAmount);
                    break;

            }

            Console.WriteLine("Finished creation of training and testing subsets.");
        }

        public void I(IEnumerable<int> series, SetType type)
        {
            StringBuilder sb = new StringBuilder();

            foreach(int ion in series)
            {
                if(type == SetType.ArgLine)
                {
                    UserAction = true;

                    UserAction = false;
                }
                sb.Append(ion);
                sb.Append(',');
            }
            if(sb.Length > 1)
            {
                sb.Remove(sb.Length - 1, 1);
            }
            ArgumentLine.IonSeries = sb.ToString();
        }

 public virtual string ConvertSetTypeToString(SetType set_type)
 {
     if(set_type == SetType.UPDATE_ONLY)
         return "updateonly";
     else if(set_type == SetType.INSERT_ONLY)
         return "insertonly";
     else
         return "full";
 }

 public virtual bool SetVideoByUrl(SetType set_type, Video obj)
 {
     return act.SetVideoByUrl(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetSiteByCode(SetType set_type, Site obj)
 {
     return act.SetSiteByCode(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetQuestionByUuid(SetType set_type, Question obj)
 {
     return act.SetQuestionByUuid(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetProfileQuestionByQuestionIdByProfileId(SetType set_type, ProfileQuestion obj)
 {
     return act.SetProfileQuestionByQuestionIdByProfileId(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetEventCategoryAssocByUuid(SetType set_type, EventCategoryAssoc obj)
 {
     return act.SetEventCategoryAssocByUuid(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetContentItemTypeByUuid(SetType set_type, ContentItemType obj)
 {
     return act.SetContentItemTypeByUuid(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetChannelByUuid(SetType set_type, Channel obj)
 {
     return act.SetChannelByUuid(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetAppByUuid(SetType set_type, App obj)
 {
     return act.SetAppByUuid(ConvertSetTypeToString(set_type), obj);
 }

 internal AuthorizationSetDefinition(SetType setType)
 {
     _setType = setType;
 }

 public virtual bool SetRewardConditionTypeByUuid(SetType set_type, RewardConditionType obj)
 {
     return act.SetRewardConditionTypeByUuid(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetProfileRewardPointsByUuid(SetType set_type, ProfileRewardPoints obj)
 {
     return act.SetProfileRewardPointsByUuid(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetProfileChannelByChannelIdByProfileId(SetType set_type, ProfileChannel obj)
 {
     return act.SetProfileChannelByChannelIdByProfileId(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetProfileOrgByUuid(SetType set_type, ProfileOrg obj)
 {
     return act.SetProfileOrgByUuid(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetEventInfoByUuid(SetType set_type, EventInfo obj)
 {
     return act.SetEventInfoByUuid(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetQuestionByChannelIdByCode(SetType set_type, Question obj)
 {
     return act.SetQuestionByChannelIdByCode(ConvertSetTypeToString(set_type), obj);
 }

 public virtual bool SetMessageByUuid(SetType set_type, Message obj)
 {
     return act.SetMessageByUuid(ConvertSetTypeToString(set_type), obj);
 }