/// <summary>
 /// Returns a perfectly boring NetAsyncDownloader.
 /// </summary>
 public NetAsyncDownloader(IUser user)
 {
     User = user;
     downloads = new List<NetAsyncDownloaderDownloadPart>();
     modules = new List<CkanModule>();
     complete_or_canceled = new ManualResetEvent(false);
 }

 /// <summary>
 /// Logs the specified <see cref="System.Exception"/> and the user information.
 /// </summary>
 /// <param name="exception">The <see cref="System.Exception"/> to log.</param>
 /// <param name="user">The user information to log.</param>
 public void Log(Exception exception, IUser user)
 {
     if (!(exception is ThreadAbortException))
     {
         Log(LogLevel.Error, exception.ToString(), user);
     }
 }

 public override bool HasTriggered(IUser user, IDocumentSession session)
 {
     var number = session.Query<Praise>()
                        .Count(praise => praise.EventDate >= DateTime.Today.AddDays(0 - Config.PeriodDays)
                                      && praise.SubjectUser.UserId == user.Id);
     return Config.NumberInPeriod <= number;
 }

		public static void AssertThatUserIsNilsPetterSundgren( IUser user )
		{
			Assert.That( user.FirstName, Is.EqualTo( "Nils-Petter" ) );
			Assert.That( user.LastName, Is.EqualTo( "Sundgren" ) );
			Assert.That( user.EmailAddress, Is.EqualTo( "[email protected]" ) );
			Assert.That( user.BirthDate.HasValue, Is.EqualTo( false ) );
		}

 public Edit_Incident_Handler(IUser user)
 {
     APF = Australian_Parachute_Federation.Instance;
     //user = APF.Searcher.Find_User("13E98653-675F-44E6-A0A2-E2E40261F8FE");
     //role = APF.Searcher.Find_Role("70CAAFBC-B595-4D98-85CF-FCDC913FDB9D");
     _userInRole = (IUserInRole)APF.Searcher.Find_User_In_Role(user.User_ID);
 }

		public static void AssertThatUserIsCarlJahnGranqvist( IUser user )
		{
			Assert.That( user.FirstName, Is.EqualTo( "Carl Jan" ) );
			Assert.That( user.LastName, Is.EqualTo( "Granqvist" ) );
			Assert.That( user.EmailAddress, Is.EqualTo( "[email protected]" ) );
			Assert.That( user.BirthDate.HasValue, Is.EqualTo( false ) );
		}

 public GetBossBattleFloorService(IUser user, ILogger logger, string floorId, string target)
     : base(user, logger)
 {
     this.floorId = floorId;
     this.target = target;
     this.apiActionPath = "tower/battle.php";
 }

        public void Compute(IUser user)
        {
            var infos = new DatabaseAccess.DatabaseManager()
                .GetDatabase()
                .GetCollection<SVNInfo>(typeof(SVNInfo).Name)
                .FindAll()                                
                .OrderBy(o => o.Date)
                .ToList();

            var count = 0;
            DateTime initialTime = infos[0].Date.ToUniversalTime();
            for (int i = 1; i < infos.Count; i++)
            {
                var ts = infos[i + 1].Date - initialTime;
                if (ts.Days >= 1 && ts.Days < 2)
                {
                    count++;
                }
                else if (!(ts.Days < 1))
                {
                    count = 0;
                }
                else
                {
                    continue;
                }
                initialTime = infos[i].Date;
                if (count >= 5)
                {
                    Gained = true;
                    break;
                }
            }
            
        }

 public ConnectStorageStage(IUser user, string ipaddress, int port)
 {
     // TODO: Complete member initialization
     this._User = user;
     this._IpAddress = ipaddress;
     this._Port = port;
 }

        private void RegisterRemoting()
        {
            {
                try
                {
                    BinaryServerFormatterSinkProvider server_provider = new BinaryServerFormatterSinkProvider();
                    server_provider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

                    BinaryClientFormatterSinkProvider client_provider = new BinaryClientFormatterSinkProvider();
                    IDictionary properties = new Hashtable();

                    properties["port"] = "0";

                    TcpChannel channel = new TcpChannel(properties, client_provider, server_provider);
                    ChannelServices.RegisterChannel(channel, false);

                    user = (IUser)Activator.GetObject(typeof(IUser), "tcp://localhost:9998/UserHandeling");
                    portal = (IPortal)Activator.GetObject(typeof(IPortal), "tcp://localhost:9998/PortalHandeling");
                    ftserver = (IFTserver)Activator.GetObject(typeof(IFTserver), "tcp://localhost:9998/TransferHandeling");
                }
                catch (RemotingException e)
                {
                    MessageBox.Show("Connection Error");
                }
            }
        }

        public void PrintCommonReceipt(bool isVoidedTransaction, string Type, string Treasury, IUser autherizedUser)
        {
            CommonUtilities CommonUtilitiesObject = new CommonUtilities();
            CommonUtilitiesObject.currentUser = autherizedUser;
            try
            { 
                switch (Type.ToUpper())
                {
                    case "PROG":
                        Type = "Progressive";
                        break;
                    case "REFILL":
                        Type = "Refills";
                        break;
                    case "REFUND":
                        Type = "Refunds";
                        break;
                    default:
                        break;
                }
                BMC.Common.LogManagement.LogManager.WriteLog("Called PrintCommonReceipt type:treasury" + Type.ToString() + " : " + Treasury.ToString()
                , BMC.Common.LogManagement.LogManager.enumLogLevel.Debug);
                CommonUtilitiesObject.GetCommonValues(isVoidedTransaction, Type, Treasury);

            }
            catch (Exception Ex)
            {
                ExceptionManager.Publish(Ex);
            }

        }

        public IUser Save(IUser user)
        {
            using (MiniProfiler.Current.Step("UserRepository.Save"))
            {
                using (var dc = DataContextFactory.GetDataContext())
                {
                    User modelAsUser = null;
                    if (String.IsNullOrEmpty(user.UniqueKey))
                        modelAsUser = new User();
                    else
                        modelAsUser = dc.Repository<User>()
                            .Where(u => u.PkID == user.UniqueKey)
                            .FirstOrDefault();

                    if (modelAsUser == null)
                        throw new ArgumentException("Attempted to Update nonexisting User");

                    modelAsUser.Username = user.Username;
                    modelAsUser.LastName = user.LastName;
                    modelAsUser.FirstName = user.FirstName;
                    modelAsUser.Birthdate = user.Birthdate;

                    if (String.IsNullOrEmpty(modelAsUser.UniqueKey))
                        dc.Insert(modelAsUser);

                    dc.Commit();

                    return user;
                }
            }
        }

        private void CreateOrUpdateOpenAuthUser(IUser user) {
            var current = _httpContextAccessor.Current();
            if (current == null)
                return;

            var request = current.Request;

            if (request == null)
                return;

            var userName = request.QueryString["UserName"];
            var externalLoginData = request.QueryString["ExternalLoginData"];

            if (string.IsNullOrWhiteSpace(userName) ||
                string.IsNullOrWhiteSpace(externalLoginData))
                return;

            string providerName;
            string providerUserId;

            if (
                !_orchardOpenAuthWebSecurity.TryDeserializeProviderUserId(HttpUtility.UrlDecode(externalLoginData), out providerName,
                                                                          out providerUserId))
                return;

            _orchardOpenAuthWebSecurity.CreateOrUpdateAccount(providerName, providerUserId, user);
        }

 public SerfidCore(IListener listener, IFilter filter, IStorage storage, IUser user)
 {
     _listener = listener;
     _filter = filter;
     _storage = storage;
     _user = user;
 }

 public MessageInfo(string text, IUser author, IEnumerable<ICategory> categories, DateTimeOffset created)
 {
     _authorId = author.Id;
     _categoryIds = categories.Select(f => f.Id).ToArray();
     _text = text;
     _created = created;
 }

        /// <summary>
        /// Gets all groups for a given user
        /// </summary>
        /// <param name="azureClient">An authenticated ActiveDirectoryClient</param>
        /// <param name="user">A resolved User object</param>
        private static void GetAllGroupsForUser(ActiveDirectoryClient azureClient, IUser user)
        {
            Console.WriteLine("");
            Console.WriteLine("Listing groups for " + user.DisplayName);
            IUserFetcher retrievedUserFetcher = (User)user;

            //access through the MemberOf collection
            IPagedCollection<IDirectoryObject> pagedCollection = retrievedUserFetcher.MemberOf.ExecuteAsync().Result; 
            do 
            { 
                List<IDirectoryObject> directoryObjects = pagedCollection.CurrentPage.ToList(); 

                foreach (IDirectoryObject directoryObject in directoryObjects) 
                { 
                    if (directoryObject is Group) 
                    { 
                        Group group = directoryObject as Group; 
                        Console.WriteLine(" Group: {0}", group.DisplayName); 
                        //add to parent collection if you need to extract them
                    } 

                    //removed to simplify 
                    //if (directoryObject is DirectoryRole) 
                    //{ 
                    //    DirectoryRole role = directoryObject as DirectoryRole; 
                    //    Console.WriteLine(" Role: {0}  Description: {1}", role.DisplayName, role.Description); 
                    //} 
                } 
                pagedCollection = pagedCollection.GetNextPageAsync().Result; 

            } while (pagedCollection != null && pagedCollection.MorePagesAvailable); 

        }

        public Matcher(IUser firstUser, IUser secondUser)
        {
            _secondUser = secondUser;
            _firstUser = firstUser;

            PeformMatch();
        }

		public static void AssertThatUserIsRolfGöranBengtsson( IUser user )
		{
			Assert.That( user.FirstName, Is.EqualTo( "Rolf-Göran" ) );
			Assert.That( user.LastName, Is.EqualTo( "Bengtsson" ) );
			Assert.That( user.EmailAddress, Is.EqualTo( "[email protected]" ) );
			Assert.That( user.BirthDate, Is.EqualTo( new DateTime( 1948, 5, 1 ) ) );
		}

 public ISession CreateSession(IUser user)
 {
     return new RavenDbSession
                {
                    User = user
                };
 }

		public static void AssertThatUserIsCarlPhilipBernadotte( IUser user )
		{
			Assert.That( user.FirstName, Is.EqualTo( "Carl-Philip" ) );
			Assert.That( user.LastName, Is.EqualTo( "Bernadotte" ) );
			Assert.That( user.EmailAddress, Is.EqualTo( "[email protected]" ) );
			Assert.That( user.BirthDate.HasValue, Is.EqualTo( false ) );
		}