/// <summary>
        /// Validates channel id.
        /// </summary>
        /// <returns></returns>
        public override void Validate(ModelStateDictionary modelState)
        {
            serviceChannel = channelService.GetServiceChannelByIdSimple(Model, publishedVersion);
            if (serviceChannel?.Id != Model)
            {
                modelState.AddModelError(PropertyName, CoreMessages.OpenApi.RecordNotFound);
                return;
            }

            // Check channel visibility
            if (userRole != UserRoleEnum.Eeva)
            {
                if (!serviceChannel.IsVisibleForAll && !((VmOpenApiServiceChannel)serviceChannel).Security.IsOwnOrganization)
                {
                    modelState.AddModelError(PropertyName, string.Format(CoreMessages.OpenApi.ChannelNotVisibleForAll, Model));
                }
            }
        }
        private IActionResult PutServiceChannel <TModel, TValidator>(TModel vmBase, TValidator validator, string channelName, string id = null, string sourceId = null)
            where TModel : class, IVmOpenApiServiceChannelIn where TValidator : ServiceChannelValidator <TModel>
        {
            // Validate the items
            if (!ModelState.IsValid)
            {
                return(new BadRequestObjectResult(ModelState));
            }

            // Set current version
            IVmOpenApiServiceChannel currentVersion = null;

            if (!string.IsNullOrEmpty(id))
            {
                vmBase.Id = id.ParseToGuid();
                if (!vmBase.Id.IsAssigned())
                {
                    return(NotFound(new VmError()
                    {
                        ErrorMessage = $"{channelName} channel with id '{id}' not found."
                    }));
                }
                currentVersion = channelService.GetServiceChannelByIdSimple(vmBase.Id.Value, false);
            }
            else if (!string.IsNullOrEmpty(sourceId))
            {
                vmBase.SourceId = sourceId;
                currentVersion  = ChannelService.GetServiceChannelBySource(sourceId);
            }

            // Check current version and data
            if (currentVersion == null || string.IsNullOrEmpty(currentVersion.PublishingStatus))
            {
                if (vmBase.Id.IsAssigned())
                {
                    return(NotFound(new VmError()
                    {
                        ErrorMessage = $"{channelName} channel with id '{id}' not found."
                    }));
                }
                else
                {
                    return(NotFound(new VmError()
                    {
                        ErrorMessage = $"{channelName} channel with source id '{vmBase.SourceId}' not found."
                    }));
                }
            }

            // Has user rights for the channel
            var isOwnOrganization = ((VmOpenApiServiceChannel)currentVersion).Security == null ? false : ((VmOpenApiServiceChannel)currentVersion).Security.IsOwnOrganization;

            if (UserRole() != UserRoleEnum.Eeva && !isOwnOrganization)
            {
                return(NotFound(new VmError()
                {
                    ErrorMessage = $"User has no rights to update or create this entity!"
                }));
            }

            // Get languages user has added into model
            vmBase.AvailableLanguages = GetServiceChannelAvailableLanguages(vmBase).ToList();

            vmBase.ChannelId = currentVersion.ChannelId;

            // Set the publishing status for vm and for validator
            vmBase.CurrentPublishingStatus    = currentVersion.PublishingStatus;
            validator.CurrentPublishingStatus = currentVersion.PublishingStatus;

            // Get the available languages from current version and from request.
            // Check if user has added new language versions. New available languages and data need to be validated (required fields need to exist in request).
            // Required languages are the ones that are just added within request.
            validator.RequiredLanguages = vmBase.AvailableLanguages.Where(i => !currentVersion.AvailableLanguages.Contains(i)).ToList();
            // Available languages is a combination from current (version) available languages and newly set available languages
            var list = new HashSet <string>();

            vmBase.AvailableLanguages.ForEach(i => list.Add(i));
            currentVersion.AvailableLanguages.ForEach(i => list.Add(i));
            validator.AvailableLanguages = list.ToList();

            // Validate request data
            validator.Validate(ModelState);
            // Check validation status
            if (!ModelState.IsValid)
            {
                return(new BadRequestObjectResult(ModelState));
            }

            SetAddressProperties(vmBase);

            return(Ok(ChannelService.SaveServiceChannel(vmBase, Settings.AllowAnonymous, versionNumber)));
        }