public Outing(TypeOfEvent eventType, int numberOfPeople, DateTime dateOfEvent, double costPerPerson)
 {
     EventType      = eventType;
     NumberOfPeople = numberOfPeople;
     DateOfEvent    = dateOfEvent;
     CostPerPerson  = costPerPerson;
 }
Beispiel #2
0
 public Outing(TypeOfEvent eventType, int attendance, DateTime eventDate, decimal perPersonCost)
 {
     EventType      = eventType;
     Attendance     = attendance;
     EventDate      = eventDate;
     PerPersonCost  = perPersonCost;
     TotalEventCost = attendance * perPersonCost;
 }
Beispiel #3
0
 public Outings(TypeOfEvent what, int guests, DateTime date, double individual, double total)
 {
     OutingType     = what;
     attendees      = guests;
     dateOfEvent    = date;
     costIndividual = individual;
     costTotal      = total;
 }
Beispiel #4
0
 public Outings(DateTime dateOfOuting, int numberOfPeople, decimal costPerPerson, decimal costForEvent, TypeOfEvent eventType)
 {
     DateOfOuting   = dateOfOuting;
     NumberOfPeople = numberOfPeople;
     CostPerPerson  = costPerPerson;
     CostForEvent   = costForEvent;
     EventType      = eventType;
 }
Beispiel #5
0
    public static void TriggerEvent(TypeOfEvent theType, EventInfo triggerInfo)
    {
        MyUnityEvent thisEvent = null;

        if (eventManager.eventDictionary.TryGetValue(theType, out thisEvent))
        {
            thisEvent.Invoke(triggerInfo);
        }
    }
Beispiel #6
0
 /// <summary>
 /// Llamamos a este método para desuscribirnos de eventos
 /// </summary>
 /// <param name="eventType"></param>
 /// <param name="listener"></param>
 public static void UnsubscribeToEvent(TypeOfEvent eventType, EventReceiver listener)
 {
     if (_events != null)
     {
         if (_events.ContainsKey(eventType))
         {
             _events[eventType] -= listener;
         }
     }
 }
Beispiel #7
0
        public void ReadUsersFromFile()
        {
            try
            {
                using (BinaryReader b = new BinaryReader(
                           File.Open("UserData.txt", FileMode.Open)))
                {
                    int pos    = 0;
                    int length = (int)b.BaseStream.Length;
                    while (pos < length)
                    {
                        Dictionary <DateTime, BettingsEvents> betsPlacedUser = new Dictionary <DateTime, BettingsEvents>();
                        string  email       = b.ReadString();
                        int     age         = b.ReadInt32();
                        string  name        = b.ReadString();
                        string  surname     = b.ReadString();
                        string  login       = b.ReadString();
                        string  password    = b.ReadString();
                        string  country     = b.ReadString();
                        string  phoneNumber = b.ReadString();
                        decimal balance     = b.ReadDecimal();
                        string  valute      = b.ReadString();
                        int     betsPlaced  = b.ReadInt32();
                        for (int i = 0; i < betsPlaced; i++)
                        {
                            string      eventStartStr      = b.ReadString();
                            DateTime    eventStart         = DateTime.Parse(eventStartStr);
                            TypeOfEvent typeOfEvent        = (TypeOfEvent)b.ReadInt32();
                            string      teamOne            = b.ReadString();
                            double      teamOneCoefitient  = b.ReadDouble();
                            decimal     teamOneMonetPlaced = b.ReadDecimal();
                            string      teamTwo            = b.ReadString();
                            double      teamTwoCoefitient  = b.ReadDouble();
                            decimal     teamTwoMoneyPlaced = b.ReadDecimal();
                            string      eventEndStr        = b.ReadString();
                            DateTime    eventEnd           = DateTime.Parse(eventEndStr);

                            BettingsEvents bettings = new BettingsEvents {
                                TeamOne = teamOne, TeamOneMonetPlaced = teamOneMonetPlaced, TeamOneCoefitient = teamOneCoefitient, TeamTwo = teamTwo, TeamTwoCoefitient = teamTwoCoefitient, TeamTwoMoneyPlaced = teamTwoMoneyPlaced, EventStart = eventStart, EventEnd = eventEnd,
                            };
                            betsPlacedUser.Add(eventStart, bettings);
                            pos += eventStartStr.Length * 2 + eventEndStr.Length * 2 + sizeof(int) + teamOne.Length * 2 + sizeof(double) * 2 + sizeof(decimal) * 2 + teamTwo.Length * 2;
                        }
                        User user = new User(name, surname, country, login, password, email, phoneNumber, age, balance, valute, betsPlacedUser);
                        betsPlacedUser.Clear();
                        users.Add(user.Email, user);
                        pos += sizeof(int) + email.Length * 2 + name.Length * 2 + surname.Length * 2 + login.Length * 2 + password.Length * 2 + country.Length * 2 + phoneNumber.Length * 2 + sizeof(decimal) + valute.Length * 2;
                    }
                }
            }
            catch (IOException e)
            {
                Console.WriteLine(e.Message + " Cant open file");
            }
        }
Beispiel #8
0
        public void ReadFromFile()
        {
            try
            {
                using (BinaryReader b = new BinaryReader(
                           File.Open("BetEvents.txt", FileMode.Open)))
                {
                    int pos    = 0;
                    int length = (int)b.BaseStream.Length;
                    while (pos < length)
                    {
                        List <BettingsEvents> bettings = new List <BettingsEvents>();
                        pos += sizeof(int);
                        TypeOfEvent typeOfEvent = (TypeOfEvent)b.ReadInt32();
                        int         eventsCount = b.ReadInt32();
                        pos += sizeof(int);
                        for (int i = 0; i < eventsCount; i++)
                        {
                            string  teamOne            = b.ReadString();
                            double  teamOneCoefitient  = b.ReadDouble();
                            decimal teamOneMoneyPlaced = b.ReadDecimal();
                            string  teamTwo            = b.ReadString();
                            double  teamTwoCoefitient  = b.ReadDouble();
                            decimal teamTwoMoneyPlaced = b.ReadDecimal();
                            string  startStr           = b.ReadString();
                            string  endStr             = b.ReadString();

                            DateTime eventStart = DateTime.Parse(startStr);
                            DateTime eventEnd   = DateTime.Parse(endStr);

                            BettingsEvents bet = new BettingsEvents
                            {
                                TeamOne            = teamOne,
                                TeamTwo            = teamTwo,
                                TeamOneCoefitient  = teamOneCoefitient,
                                TeamTwoCoefitient  = teamTwoCoefitient,
                                TeamOneMonetPlaced = teamOneMoneyPlaced,
                                TeamTwoMoneyPlaced = teamTwoMoneyPlaced,
                                EventStart         = eventStart,
                                EventEnd           = eventEnd,
                                BettingEvents      = typeOfEvent
                            };
                            bettings.Add(bet);
                            pos += teamOne.Length * 2 + sizeof(double) + sizeof(decimal) + teamTwo.Length * 2 + sizeof(double) + sizeof(decimal) + startStr.Length * 2 + endStr.Length * 2;
                        }
                        bettingEvents.Add(typeOfEvent, bettings);
                    }
                }
            }
            catch (IOException e)
            {
                Console.WriteLine(e.Message + " Cant open file");
            }
        }
        // return cost by outing type
        public decimal GetCostByOutingType(TypeOfEvent _type)
        {
            decimal _eventTypeCost = 0;

            foreach (Outing item in _listOfOutings)
            {
                if (item.EventType == _type)
                {
                    _eventTypeCost += item.TotalEventCost;
                }
            }
            return(_eventTypeCost);
        }
Beispiel #10
0
    public static void StopListening(TypeOfEvent theType, UnityAction <EventInfo> listener)
    {
        if (_eventManager == null)
        {
            return;
        }
        MyUnityEvent thisEvent = null;

        if (eventManager.eventDictionary.TryGetValue(theType, out thisEvent))
        {
            thisEvent.RemoveListener(listener);
        }
    }
Beispiel #11
0
    /// <summary>
    /// Llamamos a este método para suscribirnos a eventos
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="listener"></param>
    public static void SubscribeToEvent(TypeOfEvent eventType, EventReceiver listener)
    {
        if (_events == null)
        {
            _events = new Dictionary <TypeOfEvent, EventReceiver>();
        }

        if (!_events.ContainsKey(eventType))
        {
            _events.Add(eventType, null);
        }

        _events[eventType] += listener;
    }
Beispiel #12
0
        public double TotalCostByType(TypeOfEvent whatType)
        {
            double totalTypeCost = 0;

            foreach (Outings outing in allOutings)
            {
                if (outing.OutingType == whatType)
                {
                    totalTypeCost += outing.costTotal;
                }
            }
            Console.WriteLine($"${totalTypeCost.ToString()}");
            return(totalTypeCost);
        }
        //This method shows a list of outings by different types

        public List <Outing> ListByType(TypeOfEvent type)
        {
            List <Outing> listByType = new List <Outing>();

            foreach (Outing outing in _listOfOutings)
            {
                if (outing.EventType == type)
                {
                    listByType.Add(outing);
                }
            }

            return(listByType);
        }
Beispiel #14
0
 public Event[] GetNLastEventsBySourceId(int count, int sourceId, TypeOfEvent typeOfEvent = TypeOfEvent.Trigger, TypeOfObjectRelatedEvent relatedEvent = TypeOfObjectRelatedEvent.Trigger)
 {
     var response = _event.Get(new Get
     {
         objectids = new[]{sourceId},
         /*
         @object = relatedEvent,
         source = typeOfEvent,
         sortfield = new[] { "clock" },
         sortorder = new[] { "desc" },*/
         //limit = count
     });
     return response;
 }
Beispiel #15
0
    public static void startListen(TypeOfEvent theType, UnityAction <EventInfo> listener)
    {
        MyUnityEvent thisevent = null;

        if (eventManager.eventDictionary.TryGetValue(theType, out thisevent))
        {
            thisevent.AddListener(listener);
        }
        else
        {
            thisevent = new MyUnityEvent();
            thisevent.AddListener(listener);
            eventManager.eventDictionary.Add(theType, thisevent);
        }
    }
Beispiel #16
0
        private Dictionary <string, (int yellowCards, int goals)> GetPlayerStats(Match match)
        {
            var events = match.HomeTeamEvents.Concat(match.AwayTeamEvents);

            var goalTypes   = new TypeOfEvent[] { TypeOfEvent.Goal, TypeOfEvent.GoalPenalty, TypeOfEvent.GoalOwn };
            var playerGoals = GetEventOccurence(goalTypes, events);

            var yellowCardTypes   = new TypeOfEvent[] { TypeOfEvent.YellowCard, TypeOfEvent.YellowCardSecond };
            var playerYellowCards = GetEventOccurence(yellowCardTypes, events);

            var result = match.HomeTeamStatistics.StartingEleven
                         .Concat(match.AwayTeamStatistics.StartingEleven)
                         .ToDictionary(p => p.Name, p => (playerYellowCards.GetValueIfExists(p.Name, 0), playerGoals.GetValueIfExists(p.Name, 0)));

            return(result);
        }
Beispiel #17
0
    /// <summary>
    /// Sobrecarga con parametros que queramos
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="parametersWrapper"></param>
    public static void TriggerEvent(TypeOfEvent eventType, params object[] parametersWrapper)
    {
        if (_events == null)
        {
            UnityEngine.Debug.LogWarning("No events subscribed");
            return;
        }

        if (_events.ContainsKey(eventType))
        {
            if (_events[eventType] != null)
            {
                _events[eventType](parametersWrapper);
            }
        }
    }
Beispiel #18
0
        public Event[] GetInRange(DateTime from, DateTime to, int[] hostids, TypeOfEvent typeOfEvent = TypeOfEvent.Trigger, TypeOfObjectRelatedEvent relatedEvent = TypeOfObjectRelatedEvent.Trigger)
        {
            if (from == null || to == null)
                throw new ArgumentNullException();

            var response = _event.Get(new Get
            {
                time_from = from.ToUnixTime(),
                time_till = to.ToUnixTime(),
                @object = relatedEvent,
                source = typeOfEvent,
                sortfield = new []{"eventid"},
                output = "extend",
                sortorder = new[] { "desc" }
            });
            return response;
        }
Beispiel #19
0
        public TypeOfEvent GetTypeForCost()
        {
            TypeOfEvent what = TypeOfEvent.Unknown;
            int         t    = 0;

            Console.WriteLine("What type of event would you like the total cost for?\n" +
                              "1. Golf\n" +
                              "2. Bowling\n" +
                              "3. Amusement Park\n" +
                              "4. Concert");
            try
            {
                t = Convert.ToInt32(Console.ReadLine());
            }
            catch (Exception e)
            {
                Console.WriteLine("Please select a valid option.");
            }
            switch (t)
            {
            case 1:
                what = TypeOfEvent.Golf;
                break;

            case 2:
                what = TypeOfEvent.Bowling;
                break;

            case 3:
                what = TypeOfEvent.AmusementPark;
                break;

            case 4:
                what = TypeOfEvent.Concert;
                break;

            default:
                Console.WriteLine("Please select a valid option.");
                break;
            }

            return(what);
        }
Beispiel #20
0
        public Outings GetOutingToAdd()
        {
            TypeOfEvent what       = TypeOfEvent.Unknown;
            int         guests     = -1;
            DateTime    date       = new DateTime();
            double      individual = -1;
            double      total      = -1;

            while (what == TypeOfEvent.Unknown)
            {
                Console.WriteLine("What type of event are you adding?\n" +
                                  "1. Golf\n" +
                                  "2. Bowling\n" +
                                  "3. Amusement Park\n" +
                                  "4. Concert");
                string t = Console.ReadLine();
                switch (t)
                {
                case "1":
                    what = TypeOfEvent.Golf;
                    break;

                case "2":
                    what = TypeOfEvent.Bowling;
                    break;

                case "3":
                    what = TypeOfEvent.AmusementPark;
                    break;

                case "4":
                    what = TypeOfEvent.Concert;
                    break;

                default:
                    Console.WriteLine("Please select a valid option.");
                    break;
                }
            }

            while (guests == -1)
            {
                Console.WriteLine("How many attendees were there?");
                string a = Console.ReadLine();
                try
                {
                    guests = Convert.ToInt32(a);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Please enter a valid number of individuals.");
                }
            }

            while (date == new DateTime())
            {
                Console.WriteLine("When did the event take place? (YYYY, MM, DD)");
                string d = Console.ReadLine();
                try
                {
                    date = Convert.ToDateTime(d);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Please enter a date in the given format.");
                }
            }

            while (individual == -1)
            {
                Console.WriteLine("What was the cost of an individual ticket?");
                try
                {
                    individual = Convert.ToDouble(Console.ReadLine());
                }
                catch (Exception e)
                {
                    Console.WriteLine("Please enter a valid number");
                }
            }

            total = guests * individual;

            Outings outing = new Outings(what, guests, date, individual, total);

            Console.WriteLine($"Event: {what.ToString()} \n" +
                              $"Guests: {guests} \n" +
                              $"Date: {date.ToShortDateString()} \n" +
                              $"Ticket Cost: ${individual} \n" +
                              $"Total Cost: ${total}");
            Console.ReadLine();
            return(outing);
        }
Beispiel #21
0
 public void AddListenerToList(IEventSubscriber listener, TypeOfEvent typeOfEvent)
 {
     //managerList.Add(listener);
     //managers.Add(listener, typeOfEvent);
 }
Beispiel #22
0
 public Event[] GetLastEventForPeriodByHostIds(TimeSpan span, int[]hostids, TypeOfEvent typeOfEvent = TypeOfEvent.Trigger, TypeOfObjectRelatedEvent relatedEvent = TypeOfObjectRelatedEvent.Trigger)
 {
     return GetInRange((DateTime.UtcNow - span), DateTime.UtcNow, hostids, typeOfEvent, relatedEvent);
 }
Beispiel #23
0
 public Event[] GetLastEventForPeriod(TimeSpan span, TypeOfEvent typeOfEvent = TypeOfEvent.Trigger, TypeOfObjectRelatedEvent relatedEvent = TypeOfObjectRelatedEvent.Trigger)
 {
     return GetInRange((DateTime.UtcNow - span), DateTime.UtcNow, null, typeOfEvent, relatedEvent);
 }
 public DerivedEventArgs(TypeOfEvent type)
 {
     EventType = type;
 }
Beispiel #25
0
 /// <summary>
 /// Llamamos a esta función para disparar un evento
 /// </summary>
 /// <param name="eventType"></param>
 public static void TriggerEvent(TypeOfEvent eventType)
 {
     TriggerEvent(eventType, null);
 }
 public EventPlanners(int id, TypeOfEvent e, string name, DateTime dt, String loc, Double cost, String eventRelatedInformation)
 {
     Id = id; EventType = e; Name = name; DateAndTime = dt; Venue = loc; Cost = cost;
     eveInfo = new EventInformation(eventRelatedInformation);
 }