public CalculateAnticipatedFeesStrategy(CreditContractOptions pCCO,Loan pContract, ApplicationSettings pGeneralSettings)
 {
     if(pCCO.CancelFees || pCCO.KeepExpectedInstallments)
         _cFfar = new AnticipatedFeesNotCalculate();
     else
         _cFfar = new AnticipatedFeesCalculate(pCCO,pContract);
 }

 public PreferencesViewModel(ApplicationSettings settings)
 {
     _settings = settings;
     ImageResultSize = _settings.ImageResultSize;
     Rating = _settings.Rating;
     ResetHistoryCommand = new AsyncDelegateCommand(ResetHistory);
 }

 public DecliningKeepNotExpectedInstallments(Loan contract, User pUser, ApplicationSettings pGeneralSettings)
 {
     _user = pUser;
     _generalSettings = pGeneralSettings;
     _contract = contract;
     _paidInstallments = new List<Installment>();
 }

        public SearchResultsPageViewModel(ApplicationSettings settings, INavigationService navigationService, IImageSearchService imageSearchService, IHub hub, IAccelerometer accelerometer, IStatusService statusService, IShareDataRequestedPump shareMessagePump)
        {
            _settings = settings;
            _navigationService = navigationService;
            _imageSearchService = imageSearchService;
            _hub = hub;
            _accelerometer = accelerometer;
            _statusService = statusService;

            HomeCommand = _navigationService.GoBackCommand;
            ViewDetailsCommand = new DelegateCommand(ViewDetails, () => SelectedImage != null);
            LoadMoreCommand = new AsyncDelegateCommand(LoadMore);
            ThumbnailViewCommand = new DelegateCommand(ThumbnailView);
            ListViewCommand = new DelegateCommand(ListView);
            SplitViewCommand = new DelegateCommand(SplitView);
            SettingsCommand = new DelegateCommand(Settings);

            AddImages(_settings.SelectedInstance.Images);
            shareMessagePump.DataToShare = _settings.SelectedInstance.QueryLink;
            _statusService.Title = _settings.SelectedInstance.Query;
            _accelerometer.Shaken += accelerometer_Shaken;
            _navigationService.Navigating += NavigatingFrom;

            UpdateCurrentView(CurrentView);
            _hub.Send(new UpdateTileImageCollectionMessage(_settings.SelectedInstance));
        }

        /// <summary>
        /// Initializes a new instance of the BallerburgGame class
        /// </summary>
        public BallerburgGame()
        {
            Instance = this;
              gameSettings = new GameSettings();
              playerSettings = new PlayerSettings[4];

              applicationSettings = new ApplicationSettings();

              graphics = new GraphicsDeviceManager(this)
                     {
                       PreferredBackBufferWidth = 640,
                       PreferredBackBufferHeight = 480
                     };

              graphicsManager = new BallerburgGraphicsManager();
              contentManager = new ContentManager();
              shaderManager = new ShaderManager();
              audioManager = new AudioManager(applicationSettings, contentManager);
              gameObjectManager = new GameObjectManager(contentManager, this.audioManager, this.graphicsManager);

              MousePointer = new MousePointer(this)
                         {
                           DrawOrder = 1000,
                           RestrictZone = new Rectangle(0, 0, 640, 480)
                         };
              Components.Add(MousePointer);

              // Create the screen manager component.
              screenManager = new ScreenManager(graphicsManager, contentManager, gameObjectManager, applicationSettings, gameSettings, shaderManager, audioManager, playerSettings)
                          {
                            GameMousePointer = MousePointer
                          };
        }

        public static void Main()
        {
            var applicationSettings = new ApplicationSettings();

            // Use topshelf for installing and activating the Windows service
            // http://topshelf-project.com/
            HostFactory.Run(x =>
            {
                x.Service<MailSenderService>(s =>
                {
                    s.ConstructUsing(name => new MailSenderService());
                    s.WhenStarted(tc => tc.Start());
                    s.WhenStopped(tc => tc.Stop());
                });

                // http://4sysops.com/archives/service-account-best-practices-part-1-choosing-a-service-account/
                x.RunAsLocalSystem();

                x.SetServiceName(applicationSettings.WindowsServiceMailSenderName);
                x.SetDisplayName(applicationSettings.WindowsServiceMailSenderName);
                x.SetDescription("Service for sending email");

                x.EnableServiceRecovery(rc => rc.RestartService(1));
            });
        }

        private static void CreateDatabaseSchemaAndDemoData()
        {
            CreateDatabaseSchema();

            var session = NHibernateHelper.SessionFactory.OpenSession();
            var passwordPolicy = new RegularExpressionPasswordPolicy(".{5,}$");
            var translationsRepository = new TranslationRepository(session, new InMemoryKeyValueCache());
            var applicationSettings = new ApplicationSettings();
            var encryptor = new DefaultEncryptor();

            var userRepository = new UserRepository(session, passwordPolicy, applicationSettings, encryptor);

            // Create administrators
            PocoGenerator.CreateAdministrators(userRepository);

            // Create users
            PocoGenerator.CreateUsers(100, userRepository);

            session.Transaction.Begin();

            // Create translations
            PocoGenerator.CreateTranslations(translationsRepository);

            session.Transaction.Commit();

            // Create logitems
            PocoGenerator.CreateLogItems(new NLogLogger(applicationSettings, "Console.Admin"));
        }

 protected override void ConfigureSettings(ApplicationSettings settings)
 {
     base.ConfigureSettings(settings);
     #if DEBUG
     settings.IsSingleProcess = true;
     #endif
 }

        public ApplicationStartResponse StartApplication(ApplicationSettings settings, ManualResetEvent reset)
        {
            var response = new ApplicationStartResponse();

            try
            {
                var source = _sourceFinder.FindSource(settings, response);
                if (source == null)
                {
                    response.Status = ApplicationStartStatus.CouldNotResolveApplicationSource;
                }
                else
                {
                    StartApplication(source, settings, reset);
                    response.ApplicationSourceName = source.GetType().AssemblyQualifiedName;

                    reset.WaitOne();
                    determineBottleFolders(response);
                }
            }
            catch (Exception ex)
            {
                response.ErrorMessage = ex.ToString();
                response.Status = ApplicationStartStatus.ApplicationSourceFailure;
            }

            return response;
        }

 static private int GetReportNumber(ApplicationSettings applicationSettings, string fileName)
 {
     int dataIndex = 0, refIndex = 0;
     for (; ; )
     {
         char token;
         int refStart = refIndex;
         if (!GetNextToken(applicationSettings, ref refIndex, out token))
             break;
         int length = refIndex - refStart;
         if (token == 'n' || token == 't')
             length -= 2;
         else
             length -= 1;
         dataIndex += length;
         if (token == 'n' || token == 't')
         {
             int dataStart = dataIndex;
             while (dataIndex < fileName.Length && char.IsDigit(fileName[dataIndex]))
                 ++dataIndex;
             if (token == 'n')
             {
                 int dataLength = dataIndex - dataStart;
                 if (dataLength > 0)
                     return int.Parse(fileName.Substring(dataStart, dataLength));
             }
         }
     }
     return -1;
 }

        public CalculateInstallmentsStrategy(CalculateInstallmentsOptions pCio, int pStartInstallment, OCurrency pStartAmount, int pNumberOfInstallments, ApplicationSettings pGeneralSettings)
        {
            _generalSettings = pGeneralSettings;
            OCurrency initialOLBOfContractBeforeRescheduling = Loan.InitialOlbOfContractBeforeRescheduling;

            if (pCio.IsExotic)
            {
                if (pCio.LoanType == OLoanTypes.Flat)
                    _iCi = new Flat.ExoticStrategy(pCio.StartDate, pCio.Contract, _generalSettings);
                else
                    _iCi = new Declining.ExoticStrategy(pCio.StartDate, pCio.Contract, _generalSettings);
            }
            else
            {
                if (pCio.LoanType == OLoanTypes.Flat)
                    _iCi = new FlatStrategy(pCio.StartDate, pCio.Contract, _generalSettings, initialOLBOfContractBeforeRescheduling);
                else if (pCio.LoanType == OLoanTypes.DecliningFixedInstallments)
                {
                    if (pCio.Contract.InterestRate == 0)
                        _iCi = new FlatStrategy(pCio.StartDate, pCio.Contract, _generalSettings, initialOLBOfContractBeforeRescheduling);
                    else
                        _iCi = new FixedInstallmentStrategy(pCio.StartDate, pCio.Contract, pStartInstallment, pStartAmount, pNumberOfInstallments, _generalSettings);
                }
                else
                {
                    if (pCio.Contract.InterestRate == 0)
                        _iCi = new FlatStrategy(pCio.StartDate, pCio.Contract, _generalSettings, initialOLBOfContractBeforeRescheduling);
                    else
                        _iCi = new FixedPrincipalStrategy(pCio.StartDate, pCio.Contract, _generalSettings);
                }
            }
        }

 public SavingDeposit(ApplicationSettings pApplicationSettings, ChartOfAccounts pChartOfAccounts, User pUser)
 {
     _events = new List<SavingEvent>();
     _chartOfAccounts = _FillChartOfAccounts(pChartOfAccounts);
     _applicationSettings = pApplicationSettings;
     _user = pUser;
 }

        public void listens_and_finishes_after_receiving_the_all_clear()
        {
            // trying to get the asset pipeline to shut up about
            // non-existent assets
            var settings = new ApplicationSettings
            {
                PhysicalPath = Environment.CurrentDirectory
                    .ParentDirectory().ParentDirectory().ParentDirectory()
                    .AppendPath("RemoteService")
            };

            var system = new FubuMvcSystem(settings, () => FubuApplication.DefaultPolicies().StructureMap().Bootstrap());

            system.AddRemoteSubSystem("Remote", x => {
                x.UseParallelServiceDirectory("RemoteService");
            });

            using (var context = system.CreateContext())
            {
                system.StartListeningForMessages();
                var message = new RemoteGo();
                MessageHistory.Record(MessageTrack.ForSent(message));

                var waitForWorkToFinish = MessageHistory.WaitForWorkToFinish(() => {
                    system.RemoteSubSystemFor("Remote").Runner.SendRemotely(message);
                }, timeoutMilliseconds:30000);
                waitForWorkToFinish.ShouldBeTrue();
            }
        }

        public FileOpenPickerPageViewModel(ApplicationSettings settings, IImageSearchService imageSearchService, IFileOpenPickerUiManager fileOpenPicker)
        {
            _settings = settings;
            _imageSearchService = imageSearchService;
            _fileOpenPicker = fileOpenPicker;

            SearchCommand = new AsyncDelegateCommand(Search);
        }

 protected override void ConfigureSettings(ApplicationSettings settings)
 {
     base.ConfigureSettings (settings);
     #if DEBUG
     settings.IsSingleProcess = true;
     #endif
     settings.LogSeverity = LogSeverity.LogseverityVerbose;
 }

        public FlatStrategy(DateTime pStartDate, Loan pContract, ApplicationSettings pGeneralSettings, OCurrency pInitialOLBOfContractBeforeRescheduling)
        {
            RoundingPoint = pContract.UseCents ? 2 : 0;

            _initialOLBOfContractBeforeRescheduling = pInitialOLBOfContractBeforeRescheduling;
            _contract = pContract;
            GeneralSettings = pGeneralSettings;
        }

        public static string GetPreferenceFormattedText(this string text, ApplicationSettings applicationSettings, bool pluralize)
        {
            string formattedText = text.Replace('_', ' ');
            formattedText = formattedText.MakeTitleCase();
            formattedText = formattedText.Replace(" ", "");

            return formattedText;
        }

        public void StartWatching(ApplicationSettings settings, IEnumerable<string> folders)
        {
            cleanUpWatchers();

            Console.WriteLine("Listening for file changes at");

            addDirectory(settings.PhysicalPath);
            folders.Each(addDirectory);
        }

        public void get_the_application_folder_with_a_file_but_no_physical_path()
        {
            var settings = new ApplicationSettings{
                PhysicalPath = null,
                ParentFolder = ".".ToFullPath()
            };

            settings.GetApplicationFolder().ShouldEqual(settings.ParentFolder);
        }

        public IssueViewModel(IHub messageHub, ISettings settings, IDialogService dialogService, IJiraService service)
            : base(messageHub)
        {
            _dialogService = dialogService;
            _settings = (ApplicationSettings)settings;
            _service = service;

            LoadIssueComments();
        }