コード例 #1
0
        public IActionResult UpdateEvent([FromBody] UpdateEventModel InputModel)
        {
            // Fetch Tenant ID from Bearer Token
            var tenant_id = @User.Claims.FirstOrDefault(c => c.Type == "tenant_id").Value;

            if (tenant_id == null)
            {
                return(Unauthorized());
            }

            // Event end date should not be less than start date
            if (InputModel.Event_End_Date != null)
            {
                if (InputModel.Event_End_Date < InputModel.Event_Start_Date)
                {
                    return(BadRequest("End date can not be smaller than start date."));
                }
            }
            // Map values with event model
            Event objEvent = new Event();

            objEvent._id               = InputModel._id;
            objEvent.Event_Name        = InputModel.Event_Name;
            objEvent.Event_Description = InputModel.Event_Description;
            objEvent.Event_Venue       = InputModel.Event_Venue;
            objEvent.Event_Owner       = tenant_id;
            objEvent.Event_Start_Date  = InputModel.Event_Start_Date;
            objEvent.Event_End_Date    = InputModel.Event_End_Date;

            return(Ok(_eventsService.UpdateEvent(objEvent)));
        }
コード例 #2
0
        public async Task <ActionResult> UpdateEventAsync(Guid id, UpdateEventModel updateEventModel)
        {
            if (id != updateEventModel.Id)
            {
                return(BadRequest());
            }

            var evnt = await _eventService.GetEventAsync(id);

            if (evnt is null)
            {
                return(NotFound());
            }

            var eventModel = new EventModel
            {
                Id          = id,
                Title       = updateEventModel.Title,
                Description = updateEventModel.Description,
                StartDate   = updateEventModel.StartDate,
                EndDate     = updateEventModel.EndDate,
                AllDay      = updateEventModel.AllDay,
                Place       = updateEventModel.Place
            };

            var updatedEvent = await _eventService.UpdateEventAsync(eventModel);

            return(NoContent());
        }
コード例 #3
0
        public async Task <bool> UpdateEventAsync(Guid eventId,
                                                  UpdateEventModel entity)
        {
            var updatingEvent = await _repository.GetEventAsync(eventId);

            _mapper.Map(entity, updatingEvent);

            return(await _repository.UpdateEventAsync(updatingEvent));
        }
コード例 #4
0
        public async Task <ActionResult <GetEventModel> > UpdateEvent(UpdateEventModel request)
        {
            var validationResult = _eventValidation.ValidateUpdateEvent(request);

            if (!validationResult.ValidationResult)
            {
                return(BadRequest(validationResult.ValidationMessage));
            }
            return(await _eventLogic.UpdateEvent(request));
        }
コード例 #5
0
ファイル: EventValidation.cs プロジェクト: kirill-shevch/Lume
 public (bool ValidationResult, string ValidationMessage) ValidateUpdateEvent(UpdateEventModel model)
 {
     if (!_eventRepository.CheckEventExistence(model.EventUid).Result)
     {
         return(false, ErrorDictionary.GetErrorMessage(10, _culture));
     }
     if (model.Status.HasValue && !Enum.IsDefined(typeof(EventStatus), model.Status))
     {
         return(false, ErrorDictionary.GetErrorMessage(13, _culture));
     }
     if (model.Types != null)
     {
         if (model.Types.Count != model.Types.Distinct().Count())
         {
             return(false, ErrorDictionary.GetErrorMessage(37, _culture));
         }
         if (model.Types.Count > 3)
         {
             return(false, ErrorDictionary.GetErrorMessage(35, _culture));
         }
         foreach (var type in model.Types)
         {
             if (!Enum.IsDefined(typeof(EventType), type))
             {
                 return(false, ErrorDictionary.GetErrorMessage(14, _culture));
             }
         }
     }
     if (model.MinAge.HasValue && model.MaxAge.HasValue && model.MinAge > model.MaxAge)
     {
         return(false, ErrorDictionary.GetErrorMessage(15, _culture));
     }
     if (model.StartTime.HasValue && model.EndTime.HasValue && model.StartTime > model.EndTime)
     {
         return(false, ErrorDictionary.GetErrorMessage(42, _culture));
     }
     if (model.CityId.HasValue)
     {
         var cities = _cityLogic.GetCities().Result;
         if (!cities.Any(x => x.CityId == model.CityId))
         {
             return(false, ErrorDictionary.GetErrorMessage(30, _culture));
         }
     }
     if (model.PrimaryImage != null && model.PrimaryImage.Any())
     {
         var eventModel = _eventRepository.GetEvent(model.EventUid).Result;
         if (eventModel.EventImageContentEntities.Any(x => x.IsPrimary.HasValue && x.IsPrimary.Value))
         {
             return(false, ErrorDictionary.GetErrorMessage(46, _culture));
         }
     }
     return(true, string.Empty);
 }
コード例 #6
0
        /// <summary>
        /// This method handles all the updates from the API.
        /// </summary>
        /// <param name="updateEventModel"></param>
        private void HandleApiUpdate(UpdateEventModel updateEventModel)
        {
            try
            {
                // Check if the layer values are updated and if so update them in the GameModel
                if (updateEventModel.UpdatedLayerValues != null)
                {
                    UpdateLayerValues(updateEventModel.UpdatedLayerValues);
                }

                // Check if a neighbourhood is removed
                if (updateEventModel.RemovedNeighbourhood != null)
                {
                    RemoveNeighbourhood(updateEventModel.RemovedNeighbourhood);
                }

                // Check if a visualized object is removed. For now it is probably a building
                if (updateEventModel.RemovedVisualizedObject != null)
                {
                    // Removed visualized object is just an identifier
                    RemoveVisualizedBuildings(updateEventModel.NeighbourhoodName,
                                              updateEventModel.RemovedVisualizedObject);
                }

                // Check if a neighbourhood is updated
                if (updateEventModel.UpdatedNeighbourhood != null)
                {
                    // Update age & LayerValues
                    UpdateNeighbourhood(updateEventModel.NeighbourhoodName, updateEventModel.UpdatedNeighbourhood);
                }

                if (updateEventModel.AddedNeighbourhood != null)
                {
                    AddNeighbourhood(updateEventModel.AddedNeighbourhood);
                }

                if (updateEventModel.AddedVisualizedObject != null)
                {
                    AddBuilding(updateEventModel.NeighbourhoodName, updateEventModel.AddedVisualizedObject);
                }

                CityUpdatedEvent?.Invoke();
            }
            catch (Exception e)
            {
#if UNITY_EDITOR
                Debug.LogError(e.StackTrace);
#else
                Debug.LogError(e.Message);
#endif
            }
        }
コード例 #7
0
        /// <summary>
        /// This function will check if vehicles needs to be marked as destroyed or if we need to spawn new vehicles.
        /// </summary>
        /// <param name="updateEventModel"></param>
        private void UpdateEvent(UpdateEventModel updateEventModel)
        {
            if (updateEventModel.UpdatedVisualizedObjects == null)
            {
                return;
            }

            // Select all vehicles that we currently have.
            List <VisualizedVehicleModel> oldVehicles = Vehicles.Select(x => x.VehicleModel).ToList();

            // Select all the new vehicles we got from the API.
            List <VisualizedVehicleModel> newVehicles =
                updateEventModel.UpdatedVisualizedObjects.OfType <VisualizedVehicleModel>().ToList();

            // Make a list of all the vehicles that are not in the new batch of vehicles.
            List <VisualizedVehicleModel> removedVehicles = oldVehicles.Except(newVehicles).ToList();

            // Make a list of newly added vehicles.
            List <VisualizedVehicleModel>
            addedVehicles = newVehicles.Except(oldVehicles).Where(v => v.Size > 0).ToList();

            // Remove all the old vehicles and mark them to destroy.
            foreach (VisualizedVehicleModel removedVehicle in removedVehicles)
            {
                Vehicle v = Vehicles.Single(x => x.VehicleModel.Equals(removedVehicle));

                if (v.NeighbourhoodModel.VisualizedObjects.Contains(v.VehicleModel))
                {
                    v.NeighbourhoodModel.VisualizedObjects.Remove(v.VehicleModel);
                }
                if (CameraController.Instance.FollowTargetObject == v.VehicleGameObject)
                {
                    CameraController.Instance.StopFollowingTarget();
                }
                Destroy(v.VehicleGameObject);
                Vehicles.Remove(v);
            }

            // Spawn all the new vehicles in a random order.
            foreach (VisualizedVehicleModel addedVehicle in addedVehicles)
            {
                SpawnVehicle(addedVehicle);
            }

            TrafficUpdateEvent.Invoke();
        }
コード例 #8
0
        /// <summary>
        /// Try to start the SignalR connection with the server.
        /// </summary>
        private void StartSignalR()
        {
            if (string.IsNullOrEmpty(SettingsManager.Instance.Settings.Api.EventHubEndpoint))
            {
                Debug.LogWarning("SignalR is not enabled, no endpoint is set. Real-time data is unavailable.");

                return;
            }

            _srLib = new SignalRLib();
            _srLib.Init(_hubEndpoint, HubListenerName);

            _srLib.Error += (sender, e) =>
            {
                _alertText.text =
                    $"Error retrieving live data from server! Server seems to be down.";
                AlertCanvas.SetActive(true);
#if UNITY_EDITOR
                Debug.LogError($"SignalR gives an error: {e.Message}");
#endif
            };
            _srLib.ConnectionStarted += (sender, e) => { Debug.Log("Connection with server established."); };


            _srLib.MessageReceived += (sender, e) =>
            {
                // Disable alerting text if server went back up
                if (_alertText.gameObject.activeSelf)
                {
                    _alertText.gameObject.SetActive(false);
                }

                UpdateEventModel updateEventModel = JsonParser.ParseUpdateEvent(e.Message);
                if (Application.isEditor && updateEventModel.UpdatedLayerValues == null)
                {
                    Debug.Log(e.Message);
                }
                ApiUpdateEvent?.Invoke(updateEventModel);
            };
        }
コード例 #9
0
        public void UpdateEvent(UpdateEventModel model)
        {
            var context = DataEntitiesProvider.Provide();
            var evt     = context.Events.SingleOrDefault(x => x.EIN == model.EventId);

            if (evt == null)
            {
                throw new ArgumentOutOfRangeException("Event ID " + model.EventId + " not recognised");
            }

            // TODO - valiudate

            // Calculate ranks and pentamind points
            var rankCalculator = RankCalculatorFactory.Get(evt);

            if (rankCalculator.CanCalculate(model.Entrants))
            {
                // TODO high-score-is-best
                rankCalculator.Calculate(evt.Number_in_Team, true, model.Entrants);

                // TODO some nasty hard coding for 2020 - also these big events can't be done via the desktop
                int overridingNumberOfEntrants = 0;

                /*      if (evt.OlympiadId == 25 && evt.Code == "POTH") overridingNumberOfEntrants = 1049;
                 *    if (evt.OlympiadId == 25 && evt.Code == "POOM") overridingNumberOfEntrants = 499;
                 *    if (evt.OlympiadId == 25 && evt.Code == "PO7S") overridingNumberOfEntrants = 339;
                 *    if (evt.OlympiadId == 25 && evt.Code == "POHU") overridingNumberOfEntrants = 704;
                 *    if (evt.OlympiadId == 25 && evt.Code == "PO5D") overridingNumberOfEntrants = 258;
                 *    if (evt.OlympiadId == 25 && evt.Code == "POOH") overridingNumberOfEntrants = 332;
                 *    if (evt.OlympiadId == 25 && evt.Code == "POH6") overridingNumberOfEntrants = 380;
                 *    if (evt.OlympiadId == 25 && evt.Code == "PZKK") overridingNumberOfEntrants = 380; */

                var pentaCalculator = new Penta2021Calculator();
                pentaCalculator.Calculate(evt.Number_in_Team, model.Entrants, evt.Pentamind, evt.PentamindFactor, overridingNumberOfEntrants);
            }
            // TODO - events with partners

            // Do the saving - see EventPanel. We'remissing bits such as the EventIndexer if only updating results
            // Event properties
            // Entrants
            // Entrants are *not* added here but their ranks etc are
            foreach (var e in model.Entrants)
            {
                var entrant = context.Entrants.First(x => x.EntryNumber == e.EntryNumber);
                entrant.Absent      = e.Absent;
                entrant.Medal       = (string.IsNullOrEmpty(e.Medal)) ? null : e.Medal;
                entrant.JuniorMedal = (string.IsNullOrEmpty(e.JuniorMedal)) ? null : e.JuniorMedal;
                entrant.Rank        = e.Rank;
                entrant.Score       = (string.IsNullOrWhiteSpace(e.Score)) ? null : e.Score;
                if (e.Rank > 0)
                {
                    entrant.Penta_Score = e.PentaScore;
                }
                else
                {
                    entrant.Penta_Score = null;
                }
                // zero length constraint
                entrant.Tie_break = (e.Tiebreak == "") ? null : e.Tiebreak;
                // TODO entrant.Partner = e.TeamOrPair;
            }

            context.SaveChanges();
        }
コード例 #10
0
        public async Task <GetEventModel> UpdateEvent(UpdateEventModel updateEventModel)
        {
            var eventEntity = await _eventRepository.GetEvent(updateEventModel.EventUid);

            if (!string.IsNullOrEmpty(updateEventModel.Name))
            {
                eventEntity.Name = updateEventModel.Name;
            }
            if (updateEventModel.MinAge.HasValue)
            {
                eventEntity.MinAge = updateEventModel.MinAge;
            }
            if (updateEventModel.MaxAge.HasValue)
            {
                eventEntity.MaxAge = updateEventModel.MaxAge;
            }
            if (updateEventModel.XCoordinate.HasValue)
            {
                eventEntity.XCoordinate = updateEventModel.XCoordinate.Value;
            }
            if (updateEventModel.YCoordinate.HasValue)
            {
                eventEntity.YCoordinate = updateEventModel.YCoordinate.Value;
            }
            if (!string.IsNullOrEmpty(updateEventModel.Description))
            {
                eventEntity.Description = updateEventModel.Description;
            }
            if (updateEventModel.StartTime.HasValue)
            {
                eventEntity.StartTime = updateEventModel.StartTime;
            }
            if (updateEventModel.EndTime.HasValue)
            {
                eventEntity.EndTime = updateEventModel.EndTime;
            }
            if (updateEventModel.IsOpenForInvitations.HasValue)
            {
                eventEntity.IsOpenForInvitations = updateEventModel.IsOpenForInvitations;
            }
            if (updateEventModel.IsOnline.HasValue)
            {
                eventEntity.IsOnline = updateEventModel.IsOnline;
            }
            if (updateEventModel.CityId.HasValue)
            {
                eventEntity.CityId = updateEventModel.CityId;
            }

            var images = new List <EventImageContentEntity>();

            if (updateEventModel.ExtraImages != null && updateEventModel.ExtraImages.Any())
            {
                foreach (var image in updateEventModel.ExtraImages)
                {
                    var eventImageContentUid = await _imageLogic.SaveImage(image);

                    images.Add(new EventImageContentEntity
                    {
                        EventImageContentUid = eventImageContentUid,
                        IsPrimary            = false
                    });
                }
                eventEntity.EventImageContentEntities = images;
            }
            if (updateEventModel.PrimaryImage != null && updateEventModel.PrimaryImage.Any())
            {
                var eventImageContentUid = await _imageLogic.SaveImage(updateEventModel.PrimaryImage);

                images.Add(new EventImageContentEntity
                {
                    EventImageContentUid = eventImageContentUid,
                    IsPrimary            = true
                });
            }
            eventEntity.EventImageContentEntities = images;

            if (updateEventModel.Types != null && updateEventModel.Types.Any())
            {
                await _eventRepository.RemoveEventTypes(eventEntity.EventId);

                eventEntity.EventTypes = new List <EventTypeToEventEntity>(
                    updateEventModel.Types.Select(x => new EventTypeToEventEntity {
                    EventId = eventEntity.EventId, EventTypeId = (long)x
                }));
            }
            else
            {
                eventEntity.EventTypes = null;
            }
            if (updateEventModel.Status.HasValue)
            {
                eventEntity.EventStatusId = (long)updateEventModel.Status;
            }
            eventEntity.EventStatus   = null;
            eventEntity.City          = null;
            eventEntity.Administrator = null;
            eventEntity.Participants  = null;
            eventEntity.Chat          = null;
            eventEntity.SwipeHistory  = null;
            await _eventRepository.UpdateEvent(eventEntity);

            return(await GetEvent(eventEntity.EventUid));
        }
コード例 #11
0
        /// <summary>
        /// Function to parse an update event into the correct model.
        /// If API structure changes happen it should be adjusted in here.
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        public static UpdateEventModel ParseUpdateEvent(string jsonString)
        {
            JSONNode jsonOBj = JSON.Parse(jsonString);


            UpdateEventModel updateEventModel = new UpdateEventModel();

            if (jsonOBj["neighbourhoodName"] != null)
            {
                updateEventModel.NeighbourhoodName = jsonOBj["neighbourhoodName"];
            }

            if (jsonOBj["removedNeighbourhood"] != null)
            {
                updateEventModel.RemovedNeighbourhood = jsonOBj["removedNeighbourhood"];
            }

            if (jsonOBj["addedNeighbourhood"] != null)
            {
                updateEventModel.AddedNeighbourhood = ParseNeighbourhoodModel(jsonOBj["addedNeighbourhood"]);
            }

            if (jsonOBj["updatedNeighbourhood"] != null)
            {
                updateEventModel.UpdatedNeighbourhood = ParseNeighbourhoodModel(jsonOBj["updatedNeighbourhood"]);
            }

            if (jsonOBj["removedVisualizedObject"] != null)
            {
                updateEventModel.RemovedVisualizedObject = jsonOBj["removedVisualizedObject"];
            }

            if (jsonOBj["addedVisualizedObject"] != null)
            {
                updateEventModel.AddedVisualizedObject =
                    VisualizedObjectFactory.Build(
                        jsonOBj["addedVisualizedObject"]["type"],
                        jsonOBj["addedVisualizedObject"]["size"],
                        null, jsonOBj["addedVisualizedObject"]["identifier"]);
            }

            if (jsonOBj["updatedVisualizedObjects"] != null)
            {
                List <IVisualizedObject> visualizedObjects = new List <IVisualizedObject>();
                foreach (JSONNode updatedVisualizedObjectNode in jsonOBj["updatedVisualizedObjects"].Children)
                {
                    visualizedObjects.Add(VisualizedObjectFactory.Build(
                                              updatedVisualizedObjectNode["type"],
                                              updatedVisualizedObjectNode["size"],
                                              null, updatedVisualizedObjectNode["identifier"]));
                }

                if (visualizedObjects.Count > 0)
                {
                    updateEventModel.UpdatedVisualizedObjects = visualizedObjects;
                }
            }

            if (jsonOBj["updatedLayerValues"] != null)
            {
                Dictionary <string, Dictionary <string, double> > updatedLayerValues =
                    new Dictionary <string, Dictionary <string, double> >();


                foreach (KeyValuePair <string, JSONNode> layerValue in jsonOBj["updatedLayerValues"])
                {
                    Dictionary <string, double> layerValues = new Dictionary <string, double>();
                    foreach (KeyValuePair <string, JSONNode> values in layerValue.Value)
                    {
                        layerValues.Add(values.Key, values.Value);
                    }

                    updatedLayerValues.Add(layerValue.Key, layerValues);
                }

                updateEventModel.UpdatedLayerValues = updatedLayerValues;
            }

            return(updateEventModel);
        }