public async Task <IActionResult> ProcessEvent([FromForm] Input_Event_Data event_Data)
        {
            int a = 0;

            event_Data.Inp_Event_Organiser = User.Identity.Name;



            event_Data.Categories = await _service.GetEventCategoriesAsync();

            event_Data.Audiences = await _service.GetEventAudiencesAsync();

            event_Data.Locations = await _service.GetEventLocationsAsync();

            event_Data.Languages = await _service.GetEventLanguagesAsync();

            event_Data.Formats = await _service.GetEventFormatsAsync();

            event_Data.Kinds = await _service.GetEventKindsAsync();

            event_Data.ZipCodes = await _service.GetEventZipcodesAsync();

            var ret_string = await _service.PostEventDataAsync(event_Data);

            ViewData["Message"] = ret_string;

            return(View());
        }
        public async Task <IActionResult> CreateEvent(Input_Event_Data event_Data)
        {
            var vm = new Input_Event_Data();

            vm.Categories = await _service.GetEventCategoriesAsync();

            vm.Audiences = await _service.GetEventAudiencesAsync();

            vm.Locations = await _service.GetEventLocationsAsync();

            vm.Languages = await _service.GetEventLanguagesAsync();

            vm.Formats = await _service.GetEventFormatsAsync();

            vm.Kinds = await _service.GetEventKindsAsync();

            vm.ZipCodes = await _service.GetEventZipcodesAsync();

            vm.categoryFilterApplied = event_Data.categoryFilterApplied ?? 0;
            vm.audienceFilterApplied = event_Data.audienceFilterApplied ?? 0;
            vm.formatFilterApplied   = event_Data.formatFilterApplied ?? 0;
            vm.languageFilterApplied = event_Data.languageFilterApplied ?? 0;
            vm.locationFilterApplied = event_Data.locationFilterApplied ?? 0;
            vm.kindFilterApplied     = event_Data.kindFilterApplied ?? 0;
            vm.zipCodeFilterApplied  = event_Data.zipCodeFilterApplied ?? 0;

            return(View(vm));
        }
        public async Task <String> PostEventDataAsync([FromForm] Input_Event_Data data)
        {
            EventItem item;
            IFormFile file;

            file = data.File;
            item = Process_Data(data);
            var token = await GetUserTokenAsync();

            var PostEventUri = ApiPaths.EventCatalog.PostNewEventItem(baseuri);
            var ret_string   = await _client.PostEventAsync(PostEventUri, item, file, token);

            return(ret_string);
        }
        public EventItem Process_Data(Input_Event_Data data)
        {
            EventItem item = new EventItem();

            item.Inp_Event_Name      = data.Inp_Event_Name;
            item.Inp_Event_Desc      = data.Inp_Event_Desc;
            item.Inp_Start_Time      = data.Inp_Start_Time;
            item.Inp_End_Time        = data.Inp_End_Time;
            item.Inp_Price           = data.Inp_Price;
            item.Inp_Event_Organiser = data.Inp_Event_Organiser;

            foreach (var audience in data.Audiences)
            {
                if (audience.Value == data.audienceFilterApplied.ToString())
                {
                    item.Inp_Event_Audience = audience.Text;
                }
            }
            foreach (var category in data.Categories)
            {
                if (category.Value == data.categoryFilterApplied.ToString())
                {
                    item.Inp_Event_Category = category.Text;
                }
            }

            foreach (var kind in data.Kinds)
            {
                if (kind.Value == data.kindFilterApplied.ToString())
                {
                    item.Inp_Event_Kind = kind.Text;
                }
            }

            foreach (var format in data.Formats)
            {
                if (format.Value == data.formatFilterApplied.ToString())
                {
                    item.Inp_Event_Format = format.Text;
                }
            }


            foreach (var location in data.Locations)
            {
                if (location.Value == data.locationFilterApplied.ToString())
                {
                    item.Inp_Event_Location = location.Text;
                }
            }

            foreach (var language in data.Languages)
            {
                if (language.Value == data.languageFilterApplied.ToString())
                {
                    item.Inp_Event_Language = language.Text;
                }
            }

            foreach (var zipcode in data.ZipCodes)
            {
                if (zipcode.Value == data.zipCodeFilterApplied.ToString())
                {
                    item.Inp_Event_ZipCode = zipcode.Text;
                }
            }

            return(item);
        }