コード例 #1
0
        private void GetAssociatedEvents()
        {
            dataGridViewEvents.RowCount = 0;
            SourceEvent = new List <AssociatedEventList>();
            decimal price = 0;

            SAPPackageEventMapReadWrite eventMap =
                new SAPPackageEventMapReadWrite(Config._dbConnectionName);

            using (SAPDataReaderPackageEventMap readerEventMap =
                       eventMap.ReaderSelectByPackageID(_packageID))
            {
                if (readerEventMap.DataReader != null &&
                    readerEventMap.DataReader.HasRows)
                {
                    while (readerEventMap.DataReader.Read())
                    {
                        AssociatedEventList item =
                            GetItem(readerEventMap.EventID);
                        if (item != null)
                        {
                            price           += item.EventGoldPrice;
                            item.PackageType = "Gold";
                            SourceEvent.Add(item);
                        }
                    } //while (readerEventMap.DataReader.Read());
                }
            }
            labelTotalPrice.Text        = price.ToString("c");
            dataGridViewEvents.RowCount = SourceEvent.Count;
        }
コード例 #2
0
        private void buttonDelete_Click(object sender, EventArgs e)
        {
            if (_sourcePackage.Count > 0)
            {
                PackageList deletedPackage =
                    _sourcePackage[_packageCurrentIndex];

                if (deletedPackage.PackageTag)
                {
                    return;
                }

                if (Message.DeleteMessage(deletedPackage.PackageName)
                    == DialogResult.Yes)
                {
                    SAPPackageEventMapReadWrite eventMapRW =
                        new SAPPackageEventMapReadWrite(Config._dbConnectionName);

                    SAPDataSetPackageEventMap ds =
                        eventMapRW.SelectByPackageID(deletedPackage.PackageID);

                    foreach (SAPDataSetPackageEventMap.PackageEventMapRow row in ds.PackageEventMap.Rows)
                    {
                        eventMapRW.Delete(row.PackageEventMapID);
                    }

                    SAPPackageReadWrite packageRW =
                        new SAPPackageReadWrite(Config._dbConnectionName);

                    packageRW.Delete(deletedPackage.PackageID);
                    _sourcePackage.RemoveAt(_packageCurrentIndex);
                    dataGridViewPackage.RowCount = _sourcePackage.Count;
                }
            }
        }
コード例 #3
0
        private void buttonDelete_Click(object sender, EventArgs e)
        {
            if (_eventCurrentIndex >= 0)
            {
                if (_sourceEvents.Count > 0)
                {
                    EventList deletedEvent =
                        _sourceEvents[_eventCurrentIndex];
                    if (deletedEvent.EventDeleteTag)
                    {
                        return;
                    }

                    SAPPackageEventMapReadWrite eventMapRW =
                        new SAPPackageEventMapReadWrite(Config._dbConnectionName);

                    if (eventMapRW.SelectByEventID(
                            deletedEvent.EventID).PackageEventMap.Rows.Count > 0)
                    {
                        Message.DisplayMessage("Unable to delete. " +
                                               "Event is currently associated with a package.");
                        return;
                    }

                    if (Message.DeleteMessage(
                            deletedEvent.EventName) == DialogResult.Yes)
                    {
                        SAPEventReadWrite eventRW =
                            new SAPEventReadWrite(Config._dbConnectionName);
                        eventRW.Delete(deletedEvent.EventID);
                        _sourceEvents.RemoveAt(_eventCurrentIndex);
                        dataGridViewEvent.RowCount = _sourceEvents.Count;
                    }
                }
            }
        }
コード例 #4
0
        public static PackageInfo GetPackageInfo()
        {
            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);

            SAPFlight flightHelper = new SAPFlight(
                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)
                    {
                        PackageInfo.EventRow packageInfoEventRow =
                            packageInfoEventDataTable.AddEventRow(
                                eventRow.EventID,
                                packageInfoPackageRow,
                                eventRow.EventName,
                                eventRow.EventDescription,
                                eventRow.EventDate.ToString(),
                                eventRow.VenueName,
                                0,
                                0,
                                0);

                        string venueCity = string.Empty;
                        using (SAPDataReaderVenue venueReader = venue.ReaderSelectByVenueID(eventRow.VenueID))
                        {
                            if (venueReader.DataReader.HasRows)
                            {
                                venueReader.DataReader.Read();
                                venueCity = venueReader.VenueCity.ToUpper();
                            }
                        }

                        if (venueCity != string.Empty)
                        {
                            flightHelper.GetList(string.Empty, venueCity);
                            foreach (SAPServices.SAP_FLIGHTLIST.BAPISFLDAT flight in flightHelper._flightList)
                            {
                                //flight dates should be between today and before the event date
                                if (Convert.ToDateTime(flight.FLIGHTDATE) > DateTime.Today &&
                                    Convert.ToDateTime(flight.FLIGHTDATE) < eventRow.EventDate)
                                {
                                    flightHelper.CheckAvailability(flight.AIRLINEID, flight.CONNECTID, flight.FLIGHTDATE);

                                    PackageInfo.FlightRow packageInfoFlightRow =
                                        packageInfoFlightDataTable.AddFlightRow(
                                            packageInfoEventRow,
                                            flight.AIRLINE,
                                            flight.FLIGHTDATE,
                                            flight.DEPTIME,
                                            flight.AIRPORTFR,
                                            flight.CITYFROM,
                                            flight.AIRPORTTO,
                                            flight.CITYTO,
                                            flight.ARRDATE,
                                            flight.ARRTIME,
                                            flightHelper._availability.FIRSTFREE,
                                            flightHelper._availability.BUSINFREE,
                                            flightHelper._availability.ECONOFREE);

                                    packageInfoEventRow.GoldAvailability   += flightHelper._availability.FIRSTFREE;
                                    packageInfoEventRow.SilverAvailability += flightHelper._availability.BUSINFREE;
                                    packageInfoEventRow.BronzeAvailability += flightHelper._availability.ECONOFREE;
                                }
                            }
                        }
                    }
                }
            }
            return(packageInfoDataset);
        }
コード例 #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);
        }
コード例 #6
0
        private void buttonSave_Click(object sender, EventArgs e)
        {
            errorProvider.Clear();
            bool hasNoError = true;

            _packageItem = new PackageList();
            int  packageID = _packageID;
            int  packageEventMapID;
            bool isSuccess = false;

            #region Check Image file
            string fileName  = openFileDialog.FileName;
            byte[] byteImage = null;

            if (File.Exists(fileName))
            {
                byteImage = UtilityHelper.FileToByte(fileName);
            }
            else if (_packageID > 0)
            {
                byteImage = _imageSelected;
            }
            else
            {
                byteImage = UtilityHelper.BitmapToByte(Resources.blank);
            }
            #endregion

            if (textBoxName.Text.Trim().Length == 0)
            {
                errorProvider.SetError(textBoxName, "Package name is required.");
                hasNoError = false;
            }
            if (textBoxDescription.Text.Trim().Length == 0)
            {
                errorProvider.SetError(textBoxDescription, "Package description is required.");
                hasNoError = false;
            }
            if (dataGridViewEvents.RowCount == 0)
            {
                errorProvider.SetError(dataGridViewEvents, "At least one event is required.");
                hasNoError = false;
            }
            if (byteImage == null)
            {
                errorProvider.SetError(pictureBoxPoster, "Poster is required.");
                hasNoError = false;
            }

            if (!hasNoError)
            {
                return;
            }

            using (SWPTransactionDBConnection dbTransaction =
                       new SWPTransactionDBConnection(Config._dbConnectionName))
            {
                try
                {
                    SAPPackageReadWrite packageRW =
                        new SAPPackageReadWrite(dbTransaction);
                    SAPPackageEventMapReadWrite packageEventRW =
                        new SAPPackageEventMapReadWrite(dbTransaction);
                    if (_packageID == 0)
                    {
                        packageRW.Insert(
                            textBoxName.Text,
                            textBoxDescription.Text,
                            byteImage,
                            out packageID);
                        foreach (AssociatedEventList item in _sourceEvent)
                        {
                            packageEventRW.Insert(
                                packageID,
                                item.EventID,
                                out packageEventMapID);
                        }
                    }
                    else
                    {
                        packageRW.Update(
                            _packageID,
                            textBoxName.Text,
                            textBoxDescription.Text,
                            byteImage);

                        foreach (AssociatedEventList item in _removedEvent)
                        {
                            packageEventRW.Delete(item.PackageMapID);
                        }

                        foreach (AssociatedEventList item in _sourceEvent)
                        {
                            if (item.IsNewID)
                            {
                                packageEventRW.Insert(
                                    _packageID,
                                    item.EventID,
                                    out packageEventMapID);
                            }
                        }
                    }
                    dbTransaction.Transaction.Commit();
                    isSuccess = true;
                }
                catch (Exception ex)
                {
                    dbTransaction.Transaction.Rollback();

                    ErrorForm errorForm =
                        new ErrorForm(ex.Message, ex.ToString());
                    errorForm.ShowDialog(this);
                    errorForm.Close();
                }
                finally
                {
                    dbTransaction.Transaction.Dispose();
                }
            }
            if (isSuccess)
            {
                _packageItem.PackageName        = textBoxName.Text;
                _packageItem.PackageDescription = textBoxDescription.Text;
                _packageItem.PackagePhoto       = byteImage;
                _packageItem.PackageID          = packageID;
                DialogResult = DialogResult.OK;
                Close();
            }
        }
コード例 #7
0
        private void PopulateItems()
        {
            _sourceEvent = new List <AssociatedEventList>();
            if (_packageID > 0)
            {
                //get associated events
                SAPPackageEventMapReadWrite eventMap =
                    new SAPPackageEventMapReadWrite(Config._dbConnectionName);

                using (SAPDataReaderPackageEventMap readerEventMap =
                           eventMap.ReaderSelectByPackageID(_packageID))
                {
                    if (readerEventMap.DataReader != null &&
                        readerEventMap.DataReader.HasRows)
                    {
                        while (readerEventMap.DataReader.Read())
                        {
                            AssociatedEventList item =
                                GetItem(readerEventMap.EventID);
                            item.EventID      = readerEventMap.EventID;
                            item.IsNewID      = false;
                            item.PackageMapID = readerEventMap.PackageEventMapID;
                            _sourceEvent.Add(item);
                        }// while (readerEventMap.DataReader.Read());
                    }
                }
                //get pacakage info
                SAPPackageReadWrite package =
                    new SAPPackageReadWrite(Config._dbConnectionName);
                using (SAPDataReaderPackage readerPackage =
                           package.ReaderSelectByPackageID(_packageID))
                {
                    if (readerPackage.DataReader != null &&
                        readerPackage.DataReader.HasRows)
                    {
                        readerPackage.DataReader.Read();
                        textBoxName.Text        = readerPackage.PackageName;
                        textBoxDescription.Text = readerPackage.PackageDescription;
                        pictureBoxPoster.Image  =
                            UtilityHelper.ByteToImage(readerPackage.PackageImage);
                        _imageSelected = readerPackage.PackageImage;
                    }
                }
            }

            #region Create Datagrid
            dataGridViewEvents.VirtualMode = true;
            dataGridViewEvents.Columns.Add(
                CreateColumn("Name", EventNameColumn, 100, ""));
            dataGridViewEvents.Columns.Add(
                CreateColumn("Date", EventDateColumn, 100, ""));
            dataGridViewEvents.Columns.Add(
                CreateColumn("Venue", EventVenueColumn, 100, ""));
            dataGridViewEvents.Columns.Add(
                CreateColumn("Gold Price", EventGoldPriceColumn, 75, "c"));
            dataGridViewEvents.Columns.Add(
                CreateColumn("Silver", EventSilverPriceColumn, 75, "c"));
            dataGridViewEvents.Columns.Add(
                CreateColumn("Bronze", EventBronzePriceColumn, 75, "c"));


            #endregion

            _removedEvent = new List <AssociatedEventList>();
            dataGridViewEvents.RowCount = _sourceEvent.Count;
        }
コード例 #8
0
        private void GetSource()
        {
            List <EventList> unUsedEvent =
                new List <EventList>();
            List <EventList> usedEvent =
                new List <EventList>();

            _sourceEvents =
                new List <EventList>();

            SAPEventReadWrite eventRW =
                new SAPEventReadWrite(Config._dbConnectionName);

            SAPEventAttendeeAgencyMapReadWrite eventAttendyMapRW =
                new SAPEventAttendeeAgencyMapReadWrite(Config._dbConnectionName);

            SAPPackageEventMapReadWrite packageEventMapRW =
                new SAPPackageEventMapReadWrite(Config._dbConnectionName);

            using (SAPDataReaderEvent readerEvent =
                       eventRW.ReaderSelectAll())
            {
                if (readerEvent.DataReader != null &&
                    readerEvent.DataReader.HasRows)
                {
                    SAPDataSetEventAttendeeAgencyMap.EventAttendeeAgencyMapDataTable dtEventAttendee =
                        eventAttendyMapRW.SelectAll().EventAttendeeAgencyMap;
                    SAPDataSetPackageEventMap.PackageEventMapDataTable dtPackageEvent =
                        packageEventMapRW.SelectAll().PackageEventMap;

                    while (readerEvent.DataReader.Read())
                    {
                        EventList item = new EventList();
                        item.EventName        = readerEvent.EventName;
                        item.EventDescription = readerEvent.EventDescription;
                        item.EventPhoto       = readerEvent.EventPhoto;
                        item.EventID          = readerEvent.EventID;

                        DataRow[] rows =
                            dtEventAttendee.Select("EventID = " + item.EventID.ToString());

                        if (rows != null && rows.Length > 0)
                        {
                            item.EventEditTag   = true;
                            item.EventDeleteTag = true;
                            usedEvent.Add(item);
                        }
                        else
                        {
                            item.EventEditTag = false;

                            rows =
                                dtPackageEvent.Select("EventId = " + item.EventID.ToString());

                            item.EventDeleteTag =
                                (rows != null && rows.Length > 0);

                            unUsedEvent.Add(item);
                        }
                    }// while (readerEvent.DataReader.Read());
                    _sourceEvents.AddRange(unUsedEvent);
                    _sourceEvents.AddRange(usedEvent);
                }
            }

            if (_sourceEvents.Count > 0)
            {
                pictureBoxPoster.Image =
                    UtilityHelper.ByteToImage(_sourceEvents[0].EventPhoto);
            }
        }
コード例 #9
0
        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());
        }