コード例 #1
0
        public void AddProfileTabContactAddress(Table addressTable)
        {
            var contactDetail = Container.GetInstance <WindowFactory <CustomerContactListDetailWindow> >().Context;

            Select.By(contactDetail.AddressesTab.MailingAddressCodeComboBox, 1, VirtualKeyShort.ENTER);
            Click.On(contactDetail.CurrencyTabButton);
        }
コード例 #2
0
        public void UpdateAddress(Table addressTable)
        {
            var activeCustomerWindow = Container.GetInstance <WindowFactory <ActiveCustomerWindow> >().Context;

            Click.On(activeCustomerWindow.ProfilesTabItem);
            Click.On(activeCustomerWindow.GenaralButton("Addresses"));

            var addressListWindow = Container.GetInstance <WindowFactory <AddressListWindow> >().Context;

            Click.On(addressListWindow.AddButton);

            var updateAddressWindow = Container.GetInstance <WindowFactory <UpdateAddressWindow> >().Context;
            var values = addressTable.GetTableRows().Select(x => x.GetCell("Value")).ToList();

            Enter.TextInto(updateAddressWindow.AddressCode, values[0]);
            Enter.TextInto(updateAddressWindow.Line1, values[1]);
            Enter.TextInto(updateAddressWindow.Line2, values[2]);
            Enter.TextInto(updateAddressWindow.City, values[3]);
            Select.By(updateAddressWindow.Country, values[4]);
            Enter.TextInto(updateAddressWindow.DefaultPhoneNumber, values[5]);
            Enter.TextInto(updateAddressWindow.ZipPostalCode, values[6]);
            Click.On(updateAddressWindow.OkButton);

            Click.On(addressListWindow.GenaralButton("Exit"));
        }
コード例 #3
0
        public void TypesOrPurposes(Table typesTable)
        {
            Wait.For(this.GetWindow <FacilityWindow>(), window =>
            {
                Click.On(window.TypesOrPurposesTab.Header);
                Click.On(window.TypesOrPurposesTab.AddButton);

                Wait.For(this.GetWindow <WarningWindow>(), dialog =>
                {
                    Click.On(dialog.YesButton);
                });

                Wait.For(this.GetWindow <FacilityRiskTypeDetailsWindow>(), dialog =>
                {
                    Select.By(dialog.RiskType, typesTable.FindValue("Risk Type"), VirtualKeyShort.ENTER);
                    Enter.TextInto(dialog.Limit, typesTable.FindValue("Limit"));
                    Click.On(dialog.OkButton);
                });

                Click.On(window.TypesOrPurposesTab.LoanPurposeTypes);
            });

            Wait.For(this.GetWindow <FacilityLoanPurposeSelectWindow>(), window =>
            {
                Select.By(window.AvailableList, 2);
                Click.On(window.OkButton);
            });
        }
コード例 #4
0
        public void CreateDeal(string dealName, string dealAlias, string currency)
        {
            Wait.For(this.GetWindow <MainWindow>(), window =>
            {
                window.Maximize();

                Click.On(window.MenuButtonPane.Actions);
                DoubleClick.On(window.MenuButtonTreePane.FindTreeItem("Deal"));
            });

            Wait.For(this.GetWindow <DealSelectWindow>(), window =>
            {
                Click.On(window.NewRadioButton);
                Enter.TextInto(window.NameTextBox, StringHelpers.GenerateNameWithSuffix(dealName));
                Enter.TextInto(window.AliasTextBox, StringHelpers.GenerateNameWithSuffix(dealAlias));
                Select.By(window.CurrencyComboBox, currency);
                Select.By(window.DepartmentComboBox, 0);
                Click.On(window.OkButton);

                Wait.For(this.GetWindow <WarningWindow>(), dialog =>
                {
                    Click.On(dialog.YesButton);
                });
            }, WaitToFinish.YES);
        }
コード例 #5
0
        public void AddDealInternalRiskRating(Table riskRatingTable)
        {
            Wait.For(this.GetWindow <DealNotebookWindow>(), window =>
            {
                Click.On(window.RiskOrRegulatoryTab.Header);
                Click.On(window.RiskOrRegulatoryTab.AddButton);

                Wait.For(this.GetWindow <WarningWindow>(), dialog =>
                {
                    Click.On(dialog.YesButton);
                });
            });

            Wait.For(this.GetWindow <DealInternalRiskRatingDetailsWindow>(), window =>
            {
                Select.By(window.RatingComboBox, riskRatingTable.FindValue("Rating"), VirtualKeyShort.ENTER);

                Wait.For(new[] { window.ValueComboBox }, ratings =>
                {
                    Select.By(window.ValueComboBox, riskRatingTable.FindValue("Value"), VirtualKeyShort.ENTER);

                    Enter.TextInto(window.EffectiveDatePicker, riskRatingTable.FindValue("Effective Date"));
                    Enter.TextInto(window.ExpirationDatePicker, riskRatingTable.FindValue("Expiration Date"));
                    Enter.TextInto(window.PercentageTextBox, riskRatingTable.FindValue("Percent"));
                    Click.On(window.OkButton);
                });
            });
        }
コード例 #6
0
        public void CompletePersonalTab()
        {
            Wait.For(this.GetWindow <DealNotebookWindow>(), window =>
            {
                Click.On(window.PersonnelTab.Header);

                Click.On(window.PersonnelTab.ExpenseCodeButton);
                Wait.For(this.GetWindow <DealSelectExpenseCodeWindow>(), dialog =>
                {
                    Click.On(dialog.AllExpenseCodesButton);
                });

                Wait.For(this.GetWindow <CommonSelectCodeWindow>(), dialog =>
                {
                    Enter.TextInto(dialog.SearchByCodeTextBox, "000001");
                    Click.On(dialog.OkButton);
                });

                Click.On(window.PersonnelTab.SaleGroupsButton);
                Wait.For(this.GetWindow <SalesGroupsSelectionListWindow>(), dialog =>
                {
                    Select.By(dialog.AvailableTree, 0);
                    Click.On(dialog.OkButton);
                });
            });
        }
コード例 #7
0
        public void CreateNewAlias(string alias, string type)
        {
            var activeCustomerWindow = this.Container.GetInstance <WindowFactory <ActiveCustomerWindow> >().Context;

            Click.On(activeCustomerWindow.GeneralTabItem);
            Click.On(activeCustomerWindow.GeneralTab.GenaralButton("Add"));
            var newAliasWIndow = this.Container.GetInstance <WindowFactory <NewAliasWindow> >().Context;

            Select.By(newAliasWIndow.AliasTypeCombobox, type, FlaUI.Core.WindowsAPI.VirtualKeyShort.ENTER);
            Enter.TextInto(newAliasWIndow.AliasTextBox, StringHelpers.GenerateNameWithSuffix(alias));
            Click.On(newAliasWIndow.AliasOkButton);
        }
コード例 #8
0
        public void Risk()
        {
            Wait.For(this.GetWindow <FacilityWindow>(), window =>
            {
                Click.On(window.RiskTab.Header);
                Click.On(window.PricingTab.Header);
                Enter.TextInto(window.PricingTab.PastDueGraceDays, "6");
                Click.On(window.PricingTab.ModifyButton);

                Wait.For(this.GetWindow <WarningWindow>(), dialog =>
                {
                    Click.On(dialog.YesButton);
                });

                Wait.For(this.GetWindow <FacilityPenaltySpreadEditorWindow>(), dialog =>
                {
                    Enter.TextInto(dialog.PenaltySpread, "15.5");
                    Select.By(dialog.PenaltyStatus, "Waived");
                    Click.On(dialog.OkButton);
                });

                Click.On(window.PricingTab.ModifyInterestPricingButton);
            });

            Wait.For(this.GetWindow <FacilityInterestPricingWindow>(), window =>
            {
                Click.On(window.AddButton);

                Wait.For(this.GetWindow <FacilityInterestPricingAddItemWindow>(), dialog =>
                {
                    Select.By(dialog.Options, "Option", null);
                    Select.By(dialog.Type, "Libor Option");
                    Click.On(dialog.OkButton);
                });

                Wait.For(this.GetWindow <FacilityOptionConditionWindow>(), dialog =>
                {
                    Select.By(dialog.OptionName, "Libor Option");
                    Select.By(dialog.RateBasis, "Actual/360");
                    Click.On(dialog.OkButton);
                });

                Wait.For(this.GetWindow <FacilityFormulaCategoryWindow>(), dialog =>
                {
                    Click.On(dialog.Code);
                    Enter.TextInto(dialog.SpreadValue, "5");
                    Click.On(dialog.OkButton);
                });

                Click.On(window.OkButton);
            });
        }
コード例 #9
0
        private void UpdateCustomerAddress(Table addressTable)
        {
            var updateAddressWindow = Container.GetInstance <WindowFactory <UpdateAddressWindow> >().Context;
            var values = addressTable.GetTableRows().Select(x => x.GetCell("Value")).ToList();

            Enter.TextInto(updateAddressWindow.AddressCode, values[0]);
            Enter.TextInto(updateAddressWindow.Line1, values[1]);
            Enter.TextInto(updateAddressWindow.Line2, values[2]);
            Enter.TextInto(updateAddressWindow.City, values[3]);
            Select.By(updateAddressWindow.Country, values[4], FlaUI.Core.WindowsAPI.VirtualKeyShort.ENTER);
            Enter.TextInto(updateAddressWindow.DefaultPhoneNumber, values[5]);
            Enter.TextInto(updateAddressWindow.ZipPostalCode, values[6]);
            Click.On(updateAddressWindow.OkButton);
        }
コード例 #10
0
        public void AddCalendar(string calendarName)
        {
            Wait.For(this.GetWindow <DealNotebookWindow>(), window =>
            {
                Click.On(window.CalendarsTab.Header);
                Click.On(window.CalendarsTab.AddButton);
            });

            Wait.For(this.GetWindow <DealHolidayWindow>(), window =>
            {
                Select.By(window.CalendarComboBox, calendarName, VirtualKeyShort.ENTER);
                Click.On(window.OkButton);
            });
        }
コード例 #11
0
        public void AddContact(string firstName, string lastName)
        {
            var activeCustomerWindow = Container.GetInstance <WindowFactory <ActiveCustomerWindow> >().Context;

            Click.On(activeCustomerWindow.ProfilesTabItem);
            Click.On(activeCustomerWindow.GenaralButton("Contacts"));

            var contactListWindow = this.Container.GetInstance <WindowFactory <CustomerContactListWindow> >().Context;

            Click.On(contactListWindow.GenaralButton("Add"));

            var contactDetail = Container.GetInstance <WindowFactory <CustomerContactListDetailWindow> >().Context;

            Click.On(contactDetail.GeneralTabButton);
            Enter.TextInto(contactDetail.GeneralTab.FirstNameTextBox, firstName);
            Enter.TextInto(contactDetail.GeneralTab.LastNameTextBox, lastName);
            Select.By(contactDetail.GeneralTab.PreferredLanguageComboBox, "English", FlaUI.Core.WindowsAPI.VirtualKeyShort.ENTER);
            Enter.TextInto(contactDetail.GeneralTab.PrimaryPhoneTextBox, "123-2223-111");
            Enter.TextInto(contactDetail.GeneralTab.DepartmentTextBox, "Loan Department");
            Click.On(contactDetail.GeneralTab.LoanCheckBox);
            Click.On(contactDetail.GeneralTab.PrincipalCheckBox);
            Click.On(contactDetail.GeneralTab.AddPurposesButton);

            var purposeSelection = Container.GetInstance <WindowFactory <CustomerContactPurposeSelectionList> >().Context;

            Enter.TextInto(purposeSelection.SearchPurposeTextBox, "Borrower");
            //Enter.TextInto(purposeSelection.SearchPurposeTextBox, "Borrower");
            Click.On(purposeSelection.GenaralButton("OK"));

            Click.On(contactDetail.GeneralTab.GenaralButton("Add"));

            var contactMethods = Container.GetInstance <WindowFactory <CustomerContactNoticeMethodSelectionWindow> >().Context;

            Select.By(contactMethods.MethodsComboBox, "Email", VirtualKeyShort.ENTER);
            Enter.TextInto(contactMethods.EmailDocumentBox, "*****@*****.**");
            Click.On(contactMethods.GenaralButton("OK"));

            Click.On(contactDetail.AdressesTabButton);

            //currencies
            //Click.On(contactDetail.CurrencyTabButton);
            //Click.On(contactDetail.CurrencyTab.CurrenciesButton);

            //var currencies = this.Container.GetInstance<WindowFactory<CustomerContactPurposeSelectionList>>().Context;

            //Enter.TextInto(currencies.SearchPurposeTextBox, "Philippine", VirtualKeyShort.ENTER);
            //Click.On(currencies.GenaralButton("OK"));
        }
コード例 #12
0
        public void CreateNewAlias(string profile)
        {
            var activeCustomerWindow = this.Container.GetInstance <WindowFactory <ActiveCustomerWindow> >().Context;

            Click.On(activeCustomerWindow.ProfilesTabItem);
            Click.On(activeCustomerWindow.ProfileTab.AddProfileButton);
            var selectProfileWindow = this.Container.GetInstance <WindowFactory <SelectProfileWindow> >().Context;

            Select.By(selectProfileWindow.ProfileTree, 2, FlaUI.Core.WindowsAPI.VirtualKeyShort.ENTER);
            selectProfileWindow.ProfileTree.AsTree().SelectedTreeItem.Should().Be(selectProfileWindow.ProfileTree.FindChildAt(2));
            Click.On(selectProfileWindow.OkButton);

            var borrowerProfileDetails = Container.GetInstance <WindowFactory <CustomerBorrowerProfileDetailsWindow> >().Context;

            Click.On(borrowerProfileDetails.GenaralButton("OK"));
        }
コード例 #13
0
        public void CreateNewOutstandingSelect(Table outstandingTable)
        {
            var outstandingWindow = Container.GetInstance <WindowFactory <OutstandingSelectWindow> >().Context;

            Click.On(outstandingWindow.NewRadioButton, true);
            Wait.UntilVisible(outstandingWindow.DealTextBox);
            if (outstandingTable.FindValue("Deal") != null)
            {
                Enter.TextInto(outstandingWindow.DealTextBox, outstandingTable.FindValue("Deal"), VirtualKeyShort.TAB, true);
            }
            if (outstandingTable.FindValue("Pricing Option") != null)
            {
                Select.By(outstandingWindow.PricingOptionComboBox, "Libor Option");
            }
            Click.On(outstandingWindow.OkButton, true);
            this.ConfirmWarningAndQuestionWindow();
        }
コード例 #14
0
        public void PopulateCodeAndCalendarsTab(Table tableCodeCalendars)
        {
            var liborOptionWindow = Container.GetInstance <WindowFactory <DrawdownLiborOptionInitialWindow> >().Context;

            Click.On(liborOptionWindow.EventsTabItem);

            Click.On(liborOptionWindow.CodesTabItem, true);
            Select.By(liborOptionWindow.CodesTab.TreasuryReportingAreaComboBox, tableCodeCalendars.FindValue("Treasury Reporting Area"));

            Click.On(liborOptionWindow.CalendarsTabItem);
            Click.On(liborOptionWindow.CalendarTab.AddButton);

            var holidayWindow = Container.GetInstance <WindowFactory <DrawdownHolidayCalendarWindow> >().Context;

            Select.By(holidayWindow.CalendarComboBox, tableCodeCalendars.FindValue("Calendar"), VirtualKeyShort.ENTER);
            Click.On(holidayWindow.CalendarComboBox);
            Click.On(holidayWindow.OkButton, true);
        }
コード例 #15
0
        public void AddPricingRules(Table pricingOptions)
        {
            Wait.For(this.GetWindow <DealNotebookWindow>(), window =>
            {
                Click.On(window.PricingRulesTab.Header);
                Click.On(window.PricingRulesTab.AddOption);
            });

            Wait.For(this.GetWindow <DealInterestPricingOptionDetailsWindow>(), window =>
            {
                Select.By(window.AutomaticNotices, pricingOptions.FindValue("Rule"), VirtualKeyShort.ENTER);
                Select.By(window.CCY, pricingOptions.FindValue("CCY"));
                Select.By(window.InitialInfractionRate, pricingOptions.FindValue("Initial Infraction Rate"));
                Select.By(window.RoundedDecimalPrecision, pricingOptions.FindValue("Round Decimal Precision"));
                Select.By(window.NonBusinessDayRule, pricingOptions.FindValue("Non Business Day Rule"));
                Select.By(window.UtilizationImpact, pricingOptions.FindValue("Utilization Impact"));
                Click.On(window.OkButton);
            });
        }
コード例 #16
0
        public void SublimitOrCust()
        {
            Wait.For(this.GetWindow <FacilityWindow>(), window =>
            {
                Click.On(window.SublimitOrCustTab.Header);
                Click.On(window.SublimitOrCustTab.AddSublimit);

                Wait.For(this.GetWindow <FacilitySublimitDetailsWindow>(), dialog =>
                {
                    Enter.TextInto(dialog.Name, "Name");
                    Enter.TextInto(dialog.GlobalAmount, "5");
                    Select.By(dialog.Currency, "USD");
                    Click.On(dialog.ModifyRisk);


                    Wait.For(this.GetWindow <FacilityModifyRiskTypesSelectionWindow>(), childDialog =>
                    {
                        Select.By(childDialog.AvaibleList, "Deposits", VirtualKeyShort.SPACE);
                        Click.On(childDialog.OkButton);
                    });

                    Click.On(dialog.OkButton);
                });

                Click.On(window.SublimitOrCustTab.AddBorrowerOrDepositor);
            });

            Wait.For(this.GetWindow <WarningWindow>(), window =>
            {
                Click.On(window.YesButton);
            });

            Wait.For(this.GetWindow <DealBorrowerOrDepositorSelectWindow>(), window =>
            {
                Click.On(window.AddAllButton);
                Click.On(window.OkButton);
            });

            Wait.For(this.GetWindow <WarningWindow>(), window =>
            {
                Click.On(window.YesButton);
            });
        }
コード例 #17
0
        public void AddExternalRiskRating(Table riskTable)
        {
            var activeCustomerWindow = this.Container.GetInstance <WindowFactory <ActiveCustomerWindow> >().Context;

            Click.On(activeCustomerWindow.RiskTabItem, true);
            Click.On(activeCustomerWindow.GenaralButton("Delete External"));
            var alertMessage = Container.GetInstance <WindowFactory <WarningWindow> >().Context;

            Click.On(alertMessage.YesButton);
            Click.On(activeCustomerWindow.GenaralButton("Add External"));

            var exterternalRisk = this.Container.GetInstance <WindowFactory <CustomerExternalRiskRating> >().Context;
            var values          = riskTable.GetTableRows().Select(x => x.GetCell("Value")).ToList();

            Select.By(exterternalRisk.RatingTypeComboBox, values[0], VirtualKeyShort.ENTER);
            Enter.TextInto(exterternalRisk.RatingTextBox, values[1]);
            //Enter.TextInto(exterternalRisk.StartDateTextBox, values[2]);
            Click.On(exterternalRisk.OkButton);
        }
コード例 #18
0
        public void AddIternalRiskRating(Table riskTable)
        {
            var activeCustomerWindow = Container.GetInstance <WindowFactory <ActiveCustomerWindow> >().Context;

            Click.On(activeCustomerWindow.RiskTabItem, true);
            Click.On(activeCustomerWindow.GenaralButton("Add Internal"));
            var alertMessage = Container.GetInstance <WindowFactory <WarningWindow> >().Context;

            Click.On(alertMessage.YesButton);

            var internalRisk = this.Container.GetInstance <WindowFactory <CustomerInternalRiskRating> >().Context;
            var values       = riskTable.GetTableRows().Select(x => x.GetCell("Value")).ToList();

            Select.By(internalRisk.RatingTypeComboBox, values[0], VirtualKeyShort.ENTER);
            Enter.TextInto(internalRisk.RatingTextBox, values[1]);
            Enter.TextInto(internalRisk.PercentTextbox, values[2], VirtualKeyShort.TAB);
            Enter.TextInto(internalRisk.EffectiveDateTextBox, values[3], VirtualKeyShort.TAB);
            Enter.TextInto(internalRisk.ExpiryDateTextBox, values[4], VirtualKeyShort.TAB);
            Click.On(internalRisk.OkButton);
        }
コード例 #19
0
        public void AddCustomerLocation(string locationCode)
        {
            var activeCustomerWindow = Container.GetInstance <WindowFactory <ActiveCustomerWindow> >().Context;

            Click.On(activeCustomerWindow.ProfilesTabItem);
            Click.On(activeCustomerWindow.GenaralButton("Add Location"));

            var selectLocation = Container.GetInstance <WindowFactory <CommonSelectCodeWindow> >().Context;

            Click.On(selectLocation.SearchSortByCodeRadioButton);
            Enter.TextInto(selectLocation.SearchByCodeTextBox, locationCode);
            Click.On(selectLocation.OkButton);

            var borrowerDetails = Container.GetInstance <WindowFactory <CustomerBorrowerLocationDetailsWindow> >().Context;

            Enter.TextInto(borrowerDetails.ExternalIdTextBox, StringHelpers.RandomDigits(9));
            //Enter.TextInto(borrowerDetails.FirstTransactionDateTextBox, DateTime.Now.ToShortDateString());
            //Enter.TextInto(borrowerDetails.LastTransactionDateTextBox, DateTime.Now.AddDays(4).ToShortDateString());
            Enter.TextInto(borrowerDetails.TaxPayerIdTextBox, StringHelpers.RandomDigits(9));
            Select.By(borrowerDetails.PreferredLanguageComboBox, "English");
            Click.On(borrowerDetails.GenaralButton("OK"));
        }
コード例 #20
0
        public void AddCustomerRemittance()
        {
            var activeCustomerWindow = Container.GetInstance <WindowFactory <ActiveCustomerWindow> >().Context;

            Click.On(activeCustomerWindow.GenaralButton("Remittance Instructions"));

            var remittancePopup = Container.GetInstance <WindowFactory <CustomerAddRemittanceInstructionPopup> >().Context;

            Click.On(remittancePopup.StandardRemittanceRadioButton, true);
            Click.On(remittancePopup.GenaralButton("OK"), true);

            var remitInstructions = Container.GetInstance <WindowFactory <CustomerRemittanceInstructionsDetailWindow> >().Context;

            Select.By(remitInstructions.MethodComboBox, 1, VirtualKeyShort.ENTER);
            Enter.TextInto(remitInstructions.MethodDescriptionTextBox, "Test Description");
            Click.On(remitInstructions.AllLoanTypesCheckBox, true);
            Click.On(remitInstructions.SBLC_BACheckBox, true);
            Click.On(remitInstructions.ToCustCheckBox, true);
            Click.On(remitInstructions.PrincipalCheckBox, true);
            Click.On(remitInstructions.InterestCheckBox, true);
            Click.On(remitInstructions.FeesCheckBox, true);
            Enter.TextInto(remitInstructions.AccountNameTextBox, StringHelpers.GenerateNameWithSuffix("AccountNameAuto"), true);
        }
コード例 #21
0
        public void PendingDeal(Table pendingDealTable)
        {
            Wait.For(this.GetWindow <DealNotebookWindow>(), window =>
            {
                Click.On(window.OptionMenuItem);
                Click.On(window.Facilities);
            });

            Wait.For(this.GetWindow <FacilityNavigatorWindow>(), window =>
            {
                Click.On(window.AddButton);
            });

            Wait.For(this.GetWindow <DealFacilitySelectWindow>(), window =>
            {
                Enter.TextInto(window.FacilityName, pendingDealTable.FindValue("Facility Name"));
                Select.By(window.FacilityType, pendingDealTable.FindValue("Facility Type Select"));
                Enter.TextInto(window.ProposedCmtAmount, pendingDealTable.FindValue("Proposed Cmd Amount"));
                Enter.TextInto(window.AnsiId, StringHelpers.RandomString(pendingDealTable.FindValue("Ansi Id"), 5));
                Select.By(window.Currency, pendingDealTable.FindValue("Currency"));
                Click.On(window.OkButton);
            }, WaitToFinish.YES);
        }
コード例 #22
0
        public void CreatePrimary()
        {
            Wait.For(this.GetWindow <DealNotebookWindow>(), window =>
            {
                Click.On(window.DistributionMenuItem);
                Click.On(window.PrimariesMenuItem);
            });

            Close.This(this.GetWindow <DealNotebookWindow>());
            Close.This(this.GetWindow <FacilityWindow>());
            Close.This(this.GetWindow <FacilityNavigatorWindow>());

            Wait.For(this.GetWindow <PrimaryListWindow>(), window =>
            {
                Click.On(window.AddButton);

                Wait.For(this.GetWindow <PrimaryCreateWindow>(), dialog =>
                {
                    Click.On(dialog.LenderButton);

                    Wait.For(this.GetWindow <CommonSelectWindow>(), childDialog =>
                    {
                        Enter.TextInto(childDialog.IdentifyBy, "BANK 1");
                        Click.On(childDialog.SearchButton);
                    }, WaitToFinish.YES);

                    Wait.For(this.GetWindow <CommonListByShortNameWindow>(), childDialog =>
                    {
                        Select.By(childDialog.ShortNameList, 0);
                        Click.On(childDialog.OkButton);
                    }, WaitToFinish.YES);

                    Click.On(dialog.BroughtInByButton);

                    Wait.For(this.GetWindow <CommonSelectWindow>(), childDialog =>
                    {
                        Enter.TextInto(childDialog.IdentifyBy, "BANK 1");
                        Click.On(childDialog.SearchButton);
                    }, WaitToFinish.YES);

                    Wait.For(this.GetWindow <CommonListByShortNameWindow>(), childDialog =>
                    {
                        Select.By(childDialog.ShortNameList, 0);
                        Click.On(childDialog.OkButton);
                    }, WaitToFinish.YES);

                    Click.On(dialog.OkButton);
                });

                Wait.For(this.GetWindow <PrimaryPendingOrigWindow>(), dialog =>
                {
                    Click.On(dialog.Facilities.Header);
                    Enter.TextInto(dialog.SellAmount, "10");

                    //Click.On(dialog.AmountsOrDates.Header);

                    Click.On(dialog.Contacts.Header);
                    Click.On(dialog.Contacts.AddContactsButton);

                    Wait.For(this.GetWindow <ContactsCircleWindow>(), childDialog =>
                    {
                        Select.By(childDialog.AvailableList, 0);
                        Click.On(childDialog.OkButton);
                    });

                    Wait.For(this.GetWindow <ContactsSelectionWindow>(), childDialog =>
                    {
                        Click.On(childDialog.ExitButton);
                    });

                    Click.On(dialog.Codes.Header);
                    //Click.On(dialog.Maintenance);
                    //Click.On(dialog.PortfolioAllocations); // TODO:

                    Click.On(dialog.WorkflowTab.Header);
                    Select.By(dialog.WorkflowTab.WorkflowTree, 0, true);

                    Wait.For(this.GetWindow <WarningWindow>(), childDialog =>
                    {
                        Click.On(childDialog.YesButton);
                    });

                    Wait.For(this.GetWindow <PortfolioSetCircledOrLegalTradeDateWindow>(), childDialog =>
                    {
                        Click.On(childDialog.OkButton);
                    });
                });

                Close.This(this.GetWindow <PrimaryPendingOrigWindow>());

                //Click.On(window.ExitButton);
            });

            Close.This(this.GetWindow <PrimaryListWindow>());

            // OPEN DEAL HERE
            //Wait.For(this.GetWindow<DealNotebookWindow>(), window =>
            //{
            //    Click.On(window.WorkflowTab.Header);
            //    Select.By(window.WorkflowTab.WorkflowTree, 0);
            //});
        }
コード例 #23
0
        public void CompleteSummaryTab()
        {
            Wait.For(this.GetWindow <DealNotebookWindow>(), window =>
            {
                Click.On(window.SummaryTab.Header);
                Enter.TextInto(window.SummaryTab.ProposedCmt, "10");
                Click.On(window.SummaryTab.AddButton);

                Wait.For(this.GetWindow <QuestionWindow>(), dialog =>
                {
                    Click.On(dialog.YesButton);
                }, WaitToFinish.YES);

                Wait.For(this.GetWindow <CommonSelectWindow>(), dialog =>
                {
                    Enter.TextInto(dialog.IdentifyBy, "borror2014");
                    Click.On(dialog.SearchButton);
                }, WaitToFinish.YES);

                Wait.For(this.GetWindow <CommonListByShortNameWindow>(), dialog =>
                {
                    Select.By(dialog.ShortNameList, 0);
                    Click.On(dialog.OkButton);
                }, WaitToFinish.YES);

                Wait.For(this.GetWindow <DealBorrowerDetailsWindow>(), dialog =>
                {
                    Click.On(dialog.OkButton);
                }, WaitToFinish.YES);

                Click.On(window.SummaryTab.DealClassificationButton);

                Wait.For(this.GetWindow <CommonSelectCodeWindow>(), dialog =>
                {
                    //Select.By(dialog.ClassificationTree, 1);
                    Enter.TextInto(dialog.SearchByCodeTextBox, "CPF");
                    Click.On(dialog.OkButton);
                }, WaitToFinish.YES);

                Click.On(window.SummaryTab.AdminAgentButton);

                Wait.For(this.GetWindow <QuestionWindow>(), dialog =>
                {
                    Click.On(dialog.YesButton);
                });

                Wait.For(this.GetWindow <DealAdminAgentWindow>(), childDialog =>
                {
                    Click.On(childDialog.CustomerButton);

                    Wait.For(this.GetWindow <CommonSelectWindow>(), dialogTwo =>
                    {
                        Enter.TextInto(dialogTwo.IdentifyBy, "BANK 1");
                        Click.On(dialogTwo.SearchButton);
                    }, WaitToFinish.YES);

                    Wait.For(this.GetWindow <CommonListByShortNameWindow>(), dialogTwo =>
                    {
                        Select.By(dialogTwo.ShortNameList, 0);
                        Click.On(dialogTwo.OkButton);
                    }, WaitToFinish.YES);

                    Click.On(childDialog.OkButton);
                }, WaitToFinish.YES);
            });
        }