public void AddListItemMethod(BAPISCODAT item)
        {
            DateTime flightDate = FlightDate(item.FLIGHTDATE);

            if (flightDate.AddMonths(3) < _eventDate)
            {
                return;
            }
            else if (flightDate > _eventDate)
            {
                return;
            }
            else if (flightDate < DateTime.Now)
            {
                return;
            }
            else if (flightDate < _prevEventDate)
            {
                return;
            }

            //check availability first
            SAPFlightConnection flightConn = new SAPFlightConnection(Config.SAPUserName, Config.SAPPassword);

            if (!flightConn.GetDetail(
                    item.FLIGHTCONN,
                    item.FLIGHTDATE,
                    "",
                    item.AGENCYNUM))
            {
                return;
            }
            if (flightConn._bapiAvailability.Length > 0)
            {
                for (int counter = 0; counter < flightConn._bapiAvailability.Length; counter++)
                {
                    switch (_packageType)
                    {
                    case "Y":
                        if (flightConn._bapiAvailability[counter].ECONOFREE == 0)
                        {
                            return;
                        }
                        break;

                    case "C":
                        if (flightConn._bapiAvailability[counter].BUSINFREE == 0)
                        {
                            return;
                        }
                        break;

                    case "F":
                        if (flightConn._bapiAvailability[counter].FIRSTFREE == 0)
                        {
                            return;
                        }
                        break;
                    }
                }
            }
            else
            {
                return;
            }

            ListViewItem itemCreate = listViewFlight.Items.Add(item.FLIGHTDATE);

            itemCreate.SubItems.Add(item.DEPTIME);
            itemCreate.SubItems.Add(item.AIRPORTFR);
            itemCreate.SubItems.Add(item.ARRDATE);
            itemCreate.SubItems.Add(item.AIRPORTTO);
            itemCreate.SubItems.Add(item.ARRTIME);
            itemCreate.SubItems.Add(item.CITYFROM);
            itemCreate.SubItems.Add(item.CITYTO);

            FlightConnectionList itemList = new FlightConnectionList();

            itemList.AgencyNumber           = item.AGENCYNUM;
            itemList.AirportFrom            = item.AIRPORTFR;
            itemList.AirportTo              = item.AIRPORTTO;
            itemList.ArrivalDate            = item.ARRDATE;
            itemList.ArrivalTime            = item.ARRTIME;
            itemList.CityFrom               = item.CITYFROM;
            itemList.CityTo                 = item.CITYTO;
            itemList.DepartureTime          = item.DEPTIME;
            itemList.FlightConnectionNumber = item.FLIGHTCONN;
            itemList.FlightDate             = item.FLIGHTDATE;
            itemList.FlightTime             = item.FLIGHTTIME;
            itemList.NumberHops             = item.NUMHOPS;
            _connectionList.Add(itemList);

            labelNumRecords.Text = string.Format("{0} records", listViewFlight.Items.Count);
        }
        private void buttonSearch_Click(object sender, EventArgs e)
        {
            try
            {
                Cursor = Cursors.WaitCursor;
                listViewFlight.Items.Clear();
                addListItem = new AddListItem(AddListItemMethod);

                SAPFlightConnection _flightConnection = new SAPFlightConnection(Config.SAPUserName, Config.SAPPassword);

                string airlineID    = string.Empty;
                string travelAgency = string.Empty;

                if (comboBoxAirline.SelectedIndex > -1)
                {
                    airlineID = (string)comboBoxAirline.SelectedValue;
                }
                if (comboBoxTravelAgency.SelectedIndex > -1)
                {
                    travelAgency = (string)comboBoxTravelAgency.SelectedValue;
                }

                PseudoProgressForm progress = new PseudoProgressForm();
                progress.ProgressLabel = "Querying SAP...";
                BackgroundWorker bgWorker        = new BackgroundWorker();
                string           destinationTo   = comboBoxTo.Text;
                string           destinationFrom = textBoxCity.Text;

                bgWorker.DoWork +=
                    delegate(object senderWorker, DoWorkEventArgs eWorker)
                {
                    if (_flightConnection.GetList(
                            airlineID,
                            travelAgency,
                            destinationFrom,
                            destinationTo))
                    {
                        _flConn = _flightConnection._bapiConnectionList;

                        _connectionList = new List <FlightConnectionList>();

                        foreach (BAPISCODAT item
                                 in _flConn)
                        {
                            Invoke(addListItem, item);
                        }
                    }
                };
                bgWorker.RunWorkerCompleted +=
                    delegate(object senderWorker, RunWorkerCompletedEventArgs eWorker)
                {
                    progress.Close();
                    progress.Dispose();

                    if (listViewFlight.Items.Count == 0)
                    {
                        Message.DisplayMessage("No records found.");
                    }
                };

                bgWorker.RunWorkerAsync();
                progress.ShowDialog();
            }
            catch (Exception ex)
            {
                ErrorForm errorForm =
                    new ErrorForm(ex.Message, ex.ToString());
                errorForm.ShowDialog(this);
                errorForm.Close();
            }
            finally
            {
                Cursor = Cursors.Default;
            }
        }
Example #3
0
        private void buttonTicket_Click(object sender, RibbonControlEventArgs e)
        {
            PseudoProgressForm progress = new PseudoProgressForm();

            progress.ProgressLabel = "Querying SAP...";
            BackgroundWorker backgroundWorker = new BackgroundWorker();
            TicketSales      ticketDataset    = new TicketSales();

            backgroundWorker.DoWork +=
                delegate(object workSender, DoWorkEventArgs eventArg)
            {
                TicketSales.TicketSaleDataTable ticketSaleDataTable =
                    ticketDataset.TicketSale;

                SAPEventAttendeeAgencyMapReadWrite attendeeAgency =
                    new SAPEventAttendeeAgencyMapReadWrite(Config._dbConnectionName);

                SAPRefTravelAgencyReadWrite travelAgency =
                    new SAPRefTravelAgencyReadWrite(Config._dbConnectionName);

                //get all agencies where client booked flights to
                Dictionary <string, string> agencyList = new Dictionary <string, string>();
                using (SAPDataReaderEventAttendeeAgencyMap reader =
                           attendeeAgency.ReaderSelectAll())
                {
                    if (reader.DataReader.HasRows)
                    {
                        while (reader.DataReader.Read())
                        {
                            if (!agencyList.ContainsKey(reader.AgencyNumber))
                            {
                                string agencyName = string.Empty;
                                using (SAPDataReaderRefTravelAgency travelReader =
                                           travelAgency.ReaderSelectByAgencyNumber(reader.AgencyNumber))
                                {
                                    travelReader.DataReader.Read();
                                    agencyName = travelReader.AgencyName;
                                }

                                agencyList.Add(
                                    reader.AgencyNumber,
                                    agencyName);
                            }
                        }
                    }
                }

                SAPFlightTrip flightTripHelper =
                    new SAPFlightTrip(Config.SAPUserName, Config.SAPPassword);

                SAPFlightConnection flightConnectionHelper =
                    new SAPFlightConnection(Config.SAPUserName, Config.SAPPassword);

                foreach (KeyValuePair <string, string> agency in agencyList)
                {
                    TicketSales.TicketSaleRow ticketSaleRow =
                        ticketSaleDataTable.NewTicketSaleRow();

                    ticketSaleRow.AgencyName       = agency.Value;
                    ticketSaleRow.TicketsSold      = 0;
                    ticketSaleRow.TotalTicketPrice = 0;

                    flightTripHelper.GetList(string.Empty, agency.Key);

                    foreach (SAPServices.SAP_FLIGHTTRIPLIST.BAPISTRDAT flightTrip in flightTripHelper._bapiFlightTripList)
                    {
                        flightConnectionHelper.GetDetail(
                            flightTrip.FLCONN1,
                            flightTrip.FLDATE1,
                            string.Empty,
                            flightTrip.AGENCYNUM);

                        ticketSaleRow.TicketsSold      += 1;
                        ticketSaleRow.TotalTicketPrice += flightConnectionHelper._bapiPrice.PRICE_BUS1;
                    }

                    ticketSaleDataTable.AddTicketSaleRow(ticketSaleRow);
                }
            };

            backgroundWorker.RunWorkerCompleted +=
                delegate(object workSender, RunWorkerCompletedEventArgs eventArg)
            {
                progress.Close();
                progress.Dispose();

                ExcelHelper.LoadExcelSheet(
                    "TicketSalesDistribution",
                    Resources.TicketSalesDistribution,
                    ticketDataset);
            };

            backgroundWorker.RunWorkerAsync();
            progress.ShowDialog();
        }
Example #4
0
        public static PackageInfo GetPackageInfo(string agencyNumber)
        {
            PackageInfo packageInfoDataset = new PackageInfo();

            PackageInfo.PackageDataTable packageInfoPackageDataTable =
                packageInfoDataset.Package;

            PackageInfo.EventDataTable packageInfoEventDataTable =
                packageInfoDataset.Event;

            PackageInfo.FlightDataTable packageInfoFlightDataTable =
                packageInfoDataset.Flight;

            SAPPackageReadWrite package =
                new SAPPackageReadWrite(Config._dbConnectionName);

            SAPEventReadWrite events =
                new SAPEventReadWrite(Config._dbConnectionName);

            SAPVenueReadWrite venue =
                new SAPVenueReadWrite(Config._dbConnectionName);

            SAPPackageEventMapReadWrite packageEventMap =
                new SAPPackageEventMapReadWrite(Config._dbConnectionName);

            SAPFlightConnection flightConnectionHelper = new SAPFlightConnection(
                Config.SAPUserName, Config.SAPPassword);

            SAPDataSetPackage packageDataset = package.SelectAll();

            foreach (SAPDataSetPackage.PackageRow packageRow in packageDataset.Package.Rows)
            {
                PackageInfo.PackageRow packageInfoPackageRow =
                    packageInfoPackageDataTable.AddPackageRow(
                        packageRow.PackageID,
                        packageRow.PackageName,
                        packageRow.PackageDescription);

                SAPDataSetPackageEventMap packageEventMapDataset =
                    packageEventMap.SelectByPackageID(packageRow.PackageID);

                foreach (SAPDataSetPackageEventMap.PackageEventMapRow packageEventMapRow in packageEventMapDataset.PackageEventMap.Rows)
                {
                    SAPDataSetEvent eventDataset = events.SelectByEventID(packageEventMapRow.EventID);

                    foreach (SAPDataSetEvent.EventRow eventRow in eventDataset.Event.Rows)
                    {
                        string venueCity = string.Empty;
                        using (SAPDataReaderVenue venueReader = venue.ReaderSelectByVenueID(eventRow.VenueID))
                        {
                            if (venueReader.DataReader.HasRows)
                            {
                                venueReader.DataReader.Read();
                                venueCity = venueReader.VenueCity.ToUpper();
                            }
                        }

                        PackageInfo.EventRow packageInfoEventRow =
                            packageInfoEventDataTable.AddEventRow(
                                eventRow.EventID,
                                packageInfoPackageRow,
                                eventRow.EventName,
                                eventRow.EventDescription,
                                eventRow.EventDate.ToString(),
                                string.Format("{0}, {1}", eventRow.VenueName, venueCity),
                                0,
                                0,
                                0);

                        if (venueCity != string.Empty)
                        {
                            flightConnectionHelper.GetList(string.Empty, agencyNumber, string.Empty, venueCity);
                            foreach (SAPServices.SAP_FLIGHTCONNLIST.BAPISCODAT flight in flightConnectionHelper._bapiConnectionList)
                            {
                                //flight dates should be between today and before the event date
                                if (Convert.ToDateTime(flight.FLIGHTDATE) > DateTime.Today &&
                                    Convert.ToDateTime(flight.FLIGHTDATE) < eventRow.EventDate)
                                {
                                    flightConnectionHelper.GetDetail(flight.FLIGHTCONN, flight.FLIGHTDATE, string.Empty,
                                                                     agencyNumber);

                                    PackageInfo.FlightRow packageInfoFlightRow =
                                        packageInfoFlightDataTable.AddFlightRow(
                                            packageInfoEventRow,
                                            flightConnectionHelper._bapiHopList[0].AIRLINE,
                                            flight.FLIGHTDATE,
                                            flight.DEPTIME,
                                            flight.AIRPORTFR,
                                            flight.CITYFROM,
                                            flight.AIRPORTTO,
                                            flight.CITYTO,
                                            flight.ARRDATE,
                                            flight.ARRTIME,
                                            flightConnectionHelper._bapiAvailability[0].FIRSTFREE,
                                            flightConnectionHelper._bapiAvailability[0].BUSINFREE,
                                            flightConnectionHelper._bapiAvailability[0].ECONOFREE);

                                    packageInfoEventRow.GoldAvailability   += flightConnectionHelper._bapiAvailability[0].FIRSTFREE;
                                    packageInfoEventRow.SilverAvailability += flightConnectionHelper._bapiAvailability[0].BUSINFREE;
                                    packageInfoEventRow.BronzeAvailability += flightConnectionHelper._bapiAvailability[0].ECONOFREE;
                                }
                            }
                        }
                    }
                }
            }
            return(packageInfoDataset);
        }
Example #5
0
        public static Sales GetSalesData(int month, int year)
        {
            Sales salesDataset = new Sales();

            Sales.PackageDataTable     salesPackageDataTable     = salesDataset.Package;
            Sales.PackageSaleDataTable salesPackageSaleDataTable = salesDataset.PackageSale;

            Sales.EventDataTable     salesEventDataTable     = salesDataset.Event;
            Sales.EventSaleDataTable salesEventSaleDataTable = salesDataset.EventSale;

            Sales.FlightDataTable salesFlightDataTable = salesDataset.Flight;

            SAPPackageReadWrite package =
                new SAPPackageReadWrite(Config._dbConnectionName);

            SAPEventAttendeeReadWrite attendee =
                new SAPEventAttendeeReadWrite(Config._dbConnectionName);

            SAPEventAttendeeAgencyMapReadWrite eventAttendeeAgencyMap =
                new SAPEventAttendeeAgencyMapReadWrite(Config._dbConnectionName);

            SAPPackageEventMapReadWrite packageEventMap =
                new SAPPackageEventMapReadWrite(Config._dbConnectionName);

            SAPEventReadWrite events =
                new SAPEventReadWrite(Config._dbConnectionName);

            SAPFlightTrip flightTripHelper =
                new SAPFlightTrip(Config.SAPUserName, Config.SAPPassword);

            SAPFlightConnection flightConnectionHelper =
                new SAPFlightConnection(Config.SAPUserName, Config.SAPPassword);

            //fetch all packages
            SAPDataSetPackage packageDataset = package.SelectAll();

            //iterate through the packages
            foreach (SAPDataSetPackage.PackageRow packageRow in packageDataset.Package.Rows)
            {
                Sales.PackageRow salesPackageRow =
                    salesPackageDataTable.AddPackageRow(packageRow.PackageID, packageRow.PackageName);

                SAPDataSetEventAttendee attendeeDataset =
                    attendee.SelectByPackageID(packageRow.PackageID);

                SAPDataSetPackageEventMap packageEventMapDataset =
                    packageEventMap.SelectByPackageID(packageRow.PackageID);

                foreach (SAPDataSetEventAttendee.EventAttendeeRow eventAttendeeRow in attendeeDataset.EventAttendee.Rows)
                {
                    if ((eventAttendeeRow.Created.Month == month || month == 0) &&
                        (eventAttendeeRow.Created.Year == year || year == 0))
                    {
                        //build temp package table
                        Sales.PackageSaleRow salesPackageSaleRow =
                            salesPackageSaleDataTable.AddPackageSaleRow(
                                salesPackageRow,
                                eventAttendeeRow.EventAttendeeID,
                                eventAttendeeRow.Created,
                                eventAttendeeRow.DateOfBirth,
                                eventAttendeeRow.CustomerNumber,
                                0,
                                0);

                        SAPDataSetEventAttendeeAgencyMap eventAttendeeAgencyMapDataset =
                            eventAttendeeAgencyMap.SelectByEventAttendeeID(eventAttendeeRow.EventAttendeeID);

                        for (int i = 0; i < packageEventMapDataset.PackageEventMap.Rows.Count; i++)
                        {
                            SAPDataSetPackageEventMap.PackageEventMapRow packageEventMapRow =
                                packageEventMapDataset.PackageEventMap.Rows[i] as
                                SAPDataSetPackageEventMap.PackageEventMapRow;

                            SAPDataSetEvent eventDataset =
                                events.SelectByEventID(packageEventMapRow.EventID);

                            SAPDataSetEvent.EventRow eventRow = eventDataset.Event[0];

                            //assumes same record position as to event, need to revise!!!
                            //SAPDataSetEventAttendeeAgencyMap.EventAttendeeAgencyMapRow eventAttendeeAgencyMapRow =
                            //    eventAttendeeAgencyMapDataset.EventAttendeeAgencyMap.Rows[i] as
                            //    SAPDataSetEventAttendeeAgencyMap.EventAttendeeAgencyMapRow;

                            DataRow[] eventAttendeeAgencyMapDataRow =
                                eventAttendeeAgencyMapDataset.EventAttendeeAgencyMap.Select("EventID = " +
                                                                                            packageEventMapRow.EventID);

                            SAPDataSetEventAttendeeAgencyMap.EventAttendeeAgencyMapRow eventAttendeeAgencyMapRow =
                                eventAttendeeAgencyMapDataRow[0] as
                                SAPDataSetEventAttendeeAgencyMap.EventAttendeeAgencyMapRow;

                            Sales.EventRow salesEventRow = salesEventDataTable.FindByEventID(eventRow.EventID);
                            if (salesEventRow == null)
                            {
                                salesEventRow = salesEventDataTable.AddEventRow(
                                    eventRow.EventID,
                                    eventRow.EventName,
                                    eventRow.GoldPackagePrice,
                                    eventRow.SilverPackagePrice,
                                    eventRow.BronzePackagePrice,
                                    eventRow.GoldPackageTrueCost,
                                    eventRow.SilverPackageTrueCost,
                                    eventRow.BronzePackageTrueCost);
                            }

                            salesEventSaleDataTable.AddEventSaleRow(
                                salesEventRow,
                                packageRow.PackageID,
                                eventAttendeeRow.EventAttendeeID,
                                eventAttendeeAgencyMapRow.AgencyNumber,
                                eventAttendeeAgencyMapRow.TripNumber,
                                string.Empty,
                                0,
                                0);
                        }
                    }
                }
            }

            foreach (Sales.PackageSaleRow salesPackageSalesRow in salesPackageSaleDataTable.Rows)
            {
                foreach (DataRow row in salesPackageSalesRow.GetChildRows("PackageSale_EventSale"))
                {
                    Sales.EventSaleRow salesEventSaleRow = row as Sales.EventSaleRow;

                    flightTripHelper.GetList(
                        salesPackageSalesRow.CustomerNumber.Trim(),
                        salesEventSaleRow.AgencyNumber);

                    foreach (SAPServices.SAP_FLIGHTTRIPLIST.BAPISTRDAT trip in flightTripHelper._bapiFlightTripList)
                    {
                        if (salesEventSaleRow.TripNumber == trip.TRIPNUMBER)
                        {
                            flightConnectionHelper.GetDetail(
                                trip.FLCONN1,
                                trip.FLDATE1,
                                string.Empty,
                                salesEventSaleRow.AgencyNumber);

                            Sales.EventRow salesEventRow =
                                salesEventDataTable.FindByEventID(salesEventSaleRow.EventID);

                            decimal ticketPrice = 0;
                            switch (trip.CLASS)
                            {
                            case "F":
                                salesEventSaleRow.Cost        = salesEventRow.GoldPackageCost;
                                salesEventSaleRow.Price       = salesEventRow.GoldPackagePrice;
                                salesEventSaleRow.PackageType = "Gold";
                                ticketPrice =
                                    trip.NUMADULT == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_FST1
                                            :
                                    trip.NUMCHILD == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_FST2
                                            :
                                    trip.NUMINFANT == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_FST3
                                            : 0;
                                break;

                            case "C":
                                salesEventSaleRow.Cost        = salesEventRow.SilverPackageCost;
                                salesEventSaleRow.Price       = salesEventRow.SilverPackagePrice;
                                salesEventSaleRow.PackageType = "Silver";
                                ticketPrice =
                                    trip.NUMADULT == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_BUS1
                                            :
                                    trip.NUMCHILD == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_BUS2
                                            :
                                    trip.NUMINFANT == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_BUS3
                                            : 0;
                                break;

                            case "Y":
                                salesEventSaleRow.Cost        = salesEventRow.BronzePackageCost;
                                salesEventSaleRow.Price       = salesEventRow.BronzePackagePrice;
                                salesEventSaleRow.PackageType = "Bronze";
                                ticketPrice =
                                    trip.NUMADULT == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_ECO1
                                            :
                                    trip.NUMCHILD == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_ECO2
                                            :
                                    trip.NUMINFANT == 1
                                            ? flightConnectionHelper._bapiPrice.PRICE_ECO3
                                            : 0;
                                break;
                            }

                            salesPackageSalesRow.Cost  += salesEventSaleRow.Cost;
                            salesPackageSalesRow.Price += salesEventSaleRow.Price;

                            salesFlightDataTable.AddFlightRow(
                                salesEventSaleRow,
                                trip.FLCONN1,
                                trip.FLDATE1,
                                trip.CLASS,
                                ticketPrice,
                                trip.NUMADULT,
                                trip.NUMCHILD,
                                trip.NUMINFANT);
                        }
                    }
                }
            }
            return(salesDataset);
        }
        public static void CreateSeedData()
        {
            #region create random name/date of birth list
            Random        rand     = new Random((int)DateTime.Now.Ticks);
            int           index    = 0;
            List <string> names    = new List <string>();
            List <string> nameList =
                Properties.Resources.ValidNames.Split(
                    Environment.NewLine.ToCharArray(),
                    StringSplitOptions.RemoveEmptyEntries).ToList <string>();

            DateTime[] dobs = new DateTime[Config.SeedDataLimit * 4 + 1];

            int month = DateTime.Now.Month;
            int day   = DateTime.Now.Day;
            int year  = DateTime.Now.Year;

            int nameCounter = 0;
            do
            {
                if (!names.Contains(nameList[nameCounter]))
                {
                    names.Add(nameList[nameCounter]);
                    index = rand.Next(year - 40, year);
                    dobs[names.Count - 1] = new DateTime(index, month, day);
                    nameCounter++;
                }
            } while (names.Count < Config.SeedDataLimit * 4 + 1);

            #endregion

            cityCountry =
                new SortedDictionary <string, string>();

            SetCityCountry();

            #region Clear Tables
            SAPEventActorMapReadWrite eventActorMapRW =
                new SAPEventActorMapReadWrite(Config._dbConnectionName);

            SAPDataSetEventActorMap eventActorMapDataSet = eventActorMapRW.SelectAll();

            foreach (SAPDataSetEventActorMap.EventActorMapRow row in
                     eventActorMapDataSet.EventActorMap.Rows)
            {
                eventActorMapRW.Delete(row.EventActorMapID);
            }

            SAPEventAttendeeAgencyMapReadWrite eventAttendeeAgencyMapRW =
                new SAPEventAttendeeAgencyMapReadWrite(Config._dbConnectionName);

            SAPDataSetEventAttendeeAgencyMap eventAttendeeAgencyMapDataSet =
                eventAttendeeAgencyMapRW.SelectAll();

            foreach (SAPDataSetEventAttendeeAgencyMap.EventAttendeeAgencyMapRow row
                     in eventAttendeeAgencyMapDataSet.EventAttendeeAgencyMap.Rows)
            {
                eventAttendeeAgencyMapRW.Delete(row.EventAttendeeAgencyMapID);
            }


            SAPEventAttendeeReadWrite eventAttendeeRW =
                new SAPEventAttendeeReadWrite(Config._dbConnectionName);

            SAPDataSetEventAttendee eventAttendeeDataSet = eventAttendeeRW.SelectAll();

            foreach (SAPDataSetEventAttendee.EventAttendeeRow row in
                     eventAttendeeDataSet.EventAttendee.Rows)
            {
                eventAttendeeRW.Delete(row.EventAttendeeID);
            }

            SAPEventActorReadWrite eventActorRW =
                new SAPEventActorReadWrite(Config._dbConnectionName);

            SAPDataSetEventActor eventActorDataSet = eventActorRW.SelectAll();

            foreach (SAPDataSetEventActor.EventActorRow row in
                     eventActorDataSet.EventActor.Rows)
            {
                eventActorRW.Delete(row.EventActorID);
            }

            SAPPackageEventMapReadWrite packageEventMapRW =
                new SAPPackageEventMapReadWrite(Config._dbConnectionName);

            SAPDataSetPackageEventMap packageEventMapDataset = packageEventMapRW.SelectAll();

            foreach (SAPDataSetPackageEventMap.PackageEventMapRow row in
                     packageEventMapDataset.PackageEventMap.Rows)
            {
                packageEventMapRW.Delete(row.PackageEventMapID);
            }

            SAPPackageReadWrite packageRW =
                new SAPPackageReadWrite(Config._dbConnectionName);

            SAPDataSetPackage packageDataSet = packageRW.SelectAll();

            foreach (SAPDataSetPackage.PackageRow row in
                     packageDataSet.Package.Rows)
            {
                packageRW.Delete(row.PackageID);
            }

            SAPEventReadWrite eventRW =
                new SAPEventReadWrite(Config._dbConnectionName);

            SAPDataSetEvent eventDataSet = eventRW.SelectAll();

            foreach (SAPDataSetEvent.EventRow row in eventDataSet.Event.Rows)
            {
                eventRW.Delete(row.EventID);
            }


            SAPEventTypeReadWrite eventTypeRW =
                new SAPEventTypeReadWrite(Config._dbConnectionName);

            SAPDataSetEventType eventTypeDataSet = eventTypeRW.SelectAll();

            foreach (SAPDataSetEventType.EventTypeRow row in
                     eventTypeDataSet.EventType.Rows)
            {
                eventTypeRW.Delete(row.EventTypeID);
            }

            #endregion

            #region Repopulate Tables

            SAPEventTypeReadWrite seedEventTypeRW =
                new SAPEventTypeReadWrite(Config._dbSeedConnectionName);

            SAPDataSetEventType seedEventTypeDataSet =
                seedEventTypeRW.SelectAll();

            int retEventTypeID = 0;

            foreach (SAPDataSetEventType.EventTypeRow row in
                     seedEventTypeDataSet.EventType.Rows)
            {
                eventTypeRW.Insert(row.EventTypeName, row.EventTypeDescription, out retEventTypeID);
            }


            SAPEventReadWrite seedEventRW =
                new SAPEventReadWrite(Config._dbSeedConnectionName);

            SAPDataSetEvent seedEventDataSet = seedEventRW.SelectAll();

            int retEventID = 0;

            //check the difference in seed date to adjust the event dates
            long monthDiff = UtilityHelper.GetMonthDifference(
                Config.DateLastSeed,
                DateTime.Now);

            foreach (SAPDataSetEvent.EventRow row in
                     seedEventDataSet.Event.Rows)
            {
                using (SAPDataReaderEventType rdrSeedEventType =
                           eventTypeRW.ReaderSelectByEventTypeName(row.EventTypeName))
                {
                    if (rdrSeedEventType.DataReader != null &&
                        rdrSeedEventType.DataReader.HasRows)
                    {
                        DateTime newDate = new DateTime();
                        //long monthDifference =
                        //    UtilityHelper.GetMonthDifference(DateTime.Now, row.EventDate);

                        newDate = row.EventDate.AddMonths((int)monthDiff);

                        rdrSeedEventType.DataReader.Read();
                        eventRW.Insert(row.VenueID, rdrSeedEventType.EventTypeID, row.EventName,
                                       row.EventDescription, row.EventPhoto, newDate, row.GoldPackagePrice,
                                       row.SilverPackagePrice, row.BronzePackagePrice, row.GoldPackageTrueCost,
                                       row.SilverPackageTrueCost, row.BronzePackageTrueCost, row.EventTotalCost,
                                       out retEventID);
                    }
                }
            }

            SAPPackageReadWrite seedPackageRW =
                new SAPPackageReadWrite(Config._dbSeedConnectionName);

            SAPDataSetPackage seedPackageDataset =
                seedPackageRW.SelectAll();

            int retPackageID = 0;


            foreach (SAPDataSetPackage.PackageRow row in
                     seedPackageDataset.Package.Rows)
            {
                packageRW.Insert(row.PackageName, row.PackageDescription,
                                 row.PackageImage, out retPackageID);
            }

            int   retPackageEventMapID        = 0;
            int[] seedNumberOfEventPerPackage = { 4, 3, 4, 4 };
            int   packageIndex = 0;

            using (SAPDataReaderPackage rdrPackage = packageRW.ReaderSelectAll())
            {
                if (rdrPackage.DataReader != null &&
                    rdrPackage.DataReader.HasRows)
                {
                    int eventIdx = 0;

                    while (rdrPackage.DataReader.Read())
                    {
                        int eventID = 0;
                        for (int idx = 0; idx < seedNumberOfEventPerPackage[packageIndex]; idx++)
                        {
                            using (SAPDataReaderEvent rdrEvent = eventRW.ReaderSelectAll())
                            {
                                if (rdrEvent.DataReader != null &&
                                    rdrEvent.DataReader.HasRows)
                                {
                                    if (eventIdx == 0)
                                    {
                                        rdrEvent.DataReader.Read();
                                        eventID = rdrEvent.EventID;
                                    }
                                    else
                                    {
                                        for (int eidx = 0; eidx <= eventIdx; eidx++)
                                        {
                                            rdrEvent.DataReader.Read();
                                            eventID = rdrEvent.EventID;
                                        }
                                    }
                                }
                            }
                            packageEventMapRW.Insert(rdrPackage.PackageID, eventID, out retPackageEventMapID);
                            eventIdx++;
                        }
                        packageIndex++;
                    }
                }
            }

            #endregion

            int currentNameIndex = 0;

            //get the 3 package here

            SAPPackageEventReadOnly packageEvent =
                new SAPPackageEventReadOnly(Config._dbConnectionName);

            _flightConnection =
                new SAPFlightConnection(Config.SAPUserName, Config.SAPPassword);

            #region generate data
            using (SAPDataReaderPackage rdrPackage =
                       packageRW.ReaderSelectAll())
            {
                if (rdrPackage.DataReader != null &&
                    rdrPackage.DataReader.HasRows)
                {
                    while (rdrPackage.DataReader.Read())
                    {
                        if (Array.IndexOf(packages, rdrPackage.PackageName.ToUpper().Trim()) > -1)
                        {
                            List <string> location = new List <string>();

                            SeedEventDataList[] flights = GetEvent(rdrPackage.PackageID);

                            for (int i = 1; i <= Config.SeedDataLimit; i++)
                            {
                                DateTime previousDate = DateTime.MinValue;
                                string   cityFrom     = string.Empty;

                                #region iterate for each event
                                for (int idx = 0; idx < flights.Length; idx++)
                                {
                                    BAPISCODAT selectedItem  = null;
                                    string     selectedClass = string.Empty;
                                    if (_flightConnection.GetList("", Config.SeedTravelAgency, cityFrom, flights[idx].VenueCity))
                                    {
                                        List <int>   classTypeIndex = new List <int>();
                                        BAPISCODAT[] flightList     = _flightConnection._bapiConnectionList;
                                        do
                                        {
                                            #region random classtype
                                            if (classTypeIndex.Count < 3)
                                            {
                                                do
                                                {
                                                    int ridx = rand.Next(0, 3);
                                                    if (!classTypeIndex.Contains(ridx))
                                                    {
                                                        classTypeIndex.Add(ridx);
                                                        break;
                                                    }
                                                } while (true);
                                            }
                                            string classType = _classType[classTypeIndex[classTypeIndex.Count - 1]];
                                            #endregion

                                            foreach (BAPISCODAT item in flightList)
                                            {
                                                bool isAvailable = true;

                                                if (!IsValidFlightDate(item.FLIGHTDATE, flights[idx].EventDate, previousDate))
                                                {
                                                    continue;
                                                }

                                                isAvailable = IsFlightAvailable(item, classType);

                                                #region check if city to is not found on previous list
                                                //make sure that this is the startup point of the event
                                                if (isAvailable)
                                                {
                                                    if (previousDate == DateTime.MinValue)
                                                    {
                                                        if (location.Contains(item.CITYFROM))
                                                        {
                                                            //mark this in case there would be no more cityfrom on the list
                                                            if (selectedItem == null)
                                                            {
                                                                selectedItem  = item;
                                                                selectedClass = classType;
                                                            }
                                                        }
                                                        else
                                                        {
                                                            location.Add(item.CITYFROM);
                                                            selectedItem  = item;
                                                            selectedClass = classType;
                                                            classTypeIndex.Add(1);
                                                            classTypeIndex.Add(2);
                                                            classTypeIndex.Add(3);
                                                            break;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        selectedItem  = item;
                                                        selectedClass = classType;
                                                        classTypeIndex.Add(1);
                                                        classTypeIndex.Add(2);
                                                        classTypeIndex.Add(3);
                                                        break;
                                                    }
                                                }
                                                #endregion
                                            }
                                        } while (classTypeIndex.Count < 3);
                                    }
                                    previousDate = flights[idx].EventDate;
                                    if (selectedItem != null)
                                    {
                                        SeedEventDataList eventData = flights[idx];
                                        eventData.AgencyNum    = selectedItem.AGENCYNUM;
                                        eventData.FlightConnNo = selectedItem.FLIGHTCONN;
                                        eventData.CityFrom     = selectedItem.CITYFROM;
                                        eventData.FlightDate   = selectedItem.FLIGHTDATE;
                                        eventData.ClassType    = selectedClass;
                                        flights[idx]           = eventData;
                                        cityFrom = eventData.VenueCity;
                                    }
                                }
                                #endregion

                                #region verify if there's flight
                                bool isReady = true;
                                for (int idx = 0; idx < flights.Length; idx++)
                                {
                                    if (String.IsNullOrEmpty(flights[idx].FlightConnNo))
                                    {
                                        isReady = false;
                                    }
                                }
                                #endregion

                                if (isReady)
                                {
                                    string customerCity = flights[0].CityFrom;
                                    string customerName = names[currentNameIndex];
                                    string language     = string.Empty;
                                    string country      = GetCountry(customerCity, out language);
                                    string dob          =
                                        string.Format("{0:yyyy-MM-dd}", dobs[currentNameIndex]);
                                    string customerNumber = string.Empty;
                                    bool   isError        = false;

                                    #region save customer
                                    SAPCustomer customer =
                                        new SAPCustomer(Config.SAPUserName, Config.SAPPassword);

                                    if (customer.CreateFromData(
                                            customerCity,
                                            country,
                                            customerName,
                                            "P",
                                            "none",
                                            language,
                                            "N/A",
                                            "",
                                            ""))
                                    {
                                        //get customer number of inserted customer
                                        bool found = false;
                                        while (!found)
                                        {
                                            customer.GetList();
                                            if (customer._customerList.Length > 0)
                                            {
                                                //search last 3
                                                for (int j = customer._customerList.Length - 1;
                                                     j > (customer._customerList.Length - 3);
                                                     j--)
                                                {
                                                    if (customer._customerList[j].CUSTNAME.Trim() == customerName.Trim())
                                                    {
                                                        customerNumber = customer._customerList[j].CUSTOMERID;
                                                        found          = true;
                                                        break;
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                break;
                                            }
                                        }
                                    }
                                    else
                                    {
                                        isError = true;
                                    }
                                    #endregion

                                    #region create flight trip
                                    if (customerNumber.Length > 0)
                                    {
                                        SAPFlightTrip flightTrip =
                                            new SAPFlightTrip(Config.SAPUserName, Config.SAPPassword);
                                        for (int idx = 0; idx < flights.Length; idx++)
                                        {
                                            SeedEventDataList item = flights[idx];
                                            string            tripNumber;
                                            string            travelAgencyNumber;
                                            if (flightTrip.CreateTrip(
                                                    item.AgencyNum,
                                                    item.ClassType,
                                                    customerNumber,
                                                    item.FlightConnNo,
                                                    "",
                                                    item.FlightDate,
                                                    "",
                                                    "none",
                                                    dob,
                                                    customerName,
                                                    out travelAgencyNumber,
                                                    out tripNumber))
                                            {
                                                flights[idx].TripNumber = tripNumber;
                                            }
                                            else
                                            {
                                                isError = true;
                                            }
                                        }
                                    }
                                    #endregion

                                    #region save to local db
                                    if (!isError)
                                    {
                                        int eventAttendeeID = 0;
                                        SAPEventAttendeeReadWrite eventAttendee =
                                            new SAPEventAttendeeReadWrite(Config._dbConnectionName);
                                        DateTime dateCreate;
                                        eventAttendee.Insert(
                                            rdrPackage.PackageID,
                                            customerNumber,
                                            DateTime.Now,
                                            out dateCreate,
                                            out eventAttendeeID);

                                        for (int idx = 0; idx < flights.Length; idx++)
                                        {
                                            int eventAttendMapID = 0;
                                            SAPEventAttendeeAgencyMapReadWrite eventMap =
                                                new SAPEventAttendeeAgencyMapReadWrite(Config._dbConnectionName);
                                            eventMap.Insert(
                                                eventAttendeeID,
                                                flights[idx].EventID,
                                                flights[idx].AgencyNum,
                                                flights[idx].TripNumber,
                                                out eventAttendMapID);
                                        }
                                    }
                                    #endregion

                                    currentNameIndex++;
                                }
                                //reset flights
                                for (int idx = 0; idx < flights.Length; idx++)
                                {
                                    flights[idx].AgencyNum    = string.Empty;
                                    flights[idx].ClassType    = string.Empty;
                                    flights[idx].FlightConnNo = string.Empty;
                                    flights[idx].FlightDate   = string.Empty;
                                    flights[idx].TripNumber   = string.Empty;
                                }
                            }
                        }
                    }
                }
            }
            #endregion

            Config.UpdateKey(Config._keySeedData, "true");
            Config.UpdateKey(Config._keyDateLastSeed, DateTime.Now.ToString());
        }