private SiteResponse AddSite() { var newSite = new SiteRequest { IsTestMode = true, Name = TEST_SITE, Subdomain = TEST_SITE, }; return _gateway.Sites.AddSite(newSite); }
public async Task <ActionResult <ChannelsResult> > List([FromQuery] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, Types.SitePermissions.Channels)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (site == null) { return(NotFound()); } var channel = await _channelRepository.GetAsync(request.SiteId); var cascade = await _channelRepository.GetCascadeAsync(site, channel, async summary => { var count = await _contentRepository.GetCountAsync(site, summary); var groupNames = await _channelRepository.GetGroupNamesAsync(summary.Id); return(new { Count = count, summary.IndexName, GroupNames = groupNames, summary.Taxis, summary.ParentId }); }); var indexNames = await _channelRepository.GetChannelIndexNamesAsync(request.SiteId); var groupNameList = await _channelGroupRepository.GetGroupNamesAsync(request.SiteId); var channelTemplates = await _templateRepository.GetTemplatesByTypeAsync(request.SiteId, TemplateType.ChannelTemplate); var contentTemplates = await _templateRepository.GetTemplatesByTypeAsync(request.SiteId, TemplateType.ContentTemplate); return(new ChannelsResult { Channel = cascade, IndexNames = indexNames, GroupNames = groupNameList, ChannelTemplates = channelTemplates, ContentTemplates = contentTemplates }); }
public async Task <ActionResult <GetResult> > List([FromQuery] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.Templates)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (site == null) { return(NotFound()); } return(await GetResultAsync(site)); }
public async Task <ActionResult <UploadFileResult> > UploadFile([FromQuery] SiteRequest request, [FromForm] IFormFile file) { var siteIds = await _authManager.GetSiteIdsAsync(); if (!ListUtils.Contains(siteIds, request.SiteId)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (file == null) { return(new UploadFileResult { Error = "请选择有效的文件上传" }); } var original = Path.GetFileName(file.FileName); var fileName = _pathManager.GetUploadFileName(site, original); if (!_pathManager.IsFileExtensionAllowed(site, PathUtils.GetExtension(fileName))) { return(new UploadFileResult { Error = "请选择有效的文件上传" }); } var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.File); var filePath = PathUtils.Combine(localDirectoryPath, fileName); await _pathManager.UploadAsync(file, filePath); var fileUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true); return(new UploadFileResult { State = "SUCCESS", Url = fileUrl, Title = original, Original = original, Error = null }); }
public HttpResponseMessage CreateSiteRequest([FromBody] string value) { SiteRequest _data = null; try { _data = JsonConvert.DeserializeObject <SiteRequest>(value); var _newRequest = ObjectMapper.ToSiteRequestInformation(_data); // Handle the case when the URL is null - ie, were going to generate the URL later if (_newRequest.Url == null) { _newRequest.Url = "uri://autogenerate/" + Guid.NewGuid().ToString("N"); } ///Save the Site Request ISiteRequestFactory _srf = SiteRequestFactory.GetInstance(); var _manager = _srf.GetSiteRequestManager(); _manager.CreateNewSiteRequest(_newRequest); return(Request.CreateResponse <SiteRequest>(HttpStatusCode.Created, _data)); } catch (JsonSerializationException _ex) { var _message = string.Format("There was an error with the data. Exception {0}", _ex.Message); Log.Error("SiteRequestController.CreateSiteRequest", "There was an error creating the new site request. Error Message {0} Error Stack {1}", _ex.Message, _ex); HttpResponseMessage _response = Request.CreateResponse(HttpStatusCode.BadRequest, _message); throw new HttpResponseException(_response); } catch (Exception _ex) { var _message = string.Format("There was an error processing the request. Exception {0}", _ex.Message); HttpResponseMessage _response = Request.CreateResponse(HttpStatusCode.InternalServerError, _message); Log.Error("SiteRequestController.CreateSiteRequest", "There was an error creating the new site request. Error Message {0} Error Stack {1}", _ex.Message, _ex); throw new HttpResponseException(_response); } }
public async Task <ActionResult <GetResult> > List([FromQuery] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, Types.SitePermissions.SettingsCreateTrigger)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (site == null) { return(this.Error("无法确定内容对应的站点")); } var channel = await _channelRepository.GetAsync(request.SiteId); var cascade = await _channelRepository.GetCascadeAsync(site, channel, async summary => { var count = await _contentRepository.GetCountAsync(site, summary); var entity = await _channelRepository.GetAsync(summary.Id); var changeNames = new List <string>(); var channelIdList = ListUtils.GetIntList(entity.CreateChannelIdsIfContentChanged); foreach (var channelId in channelIdList) { if (await _channelRepository.IsExistsAsync(channelId)) { changeNames.Add(await _channelRepository.GetChannelNameNavigationAsync(request.SiteId, channelId)); } } return(new { entity.IndexName, Count = count, ChangeNames = changeNames, entity.IsCreateChannelIfContentChanged, CreateChannelIdsIfContentChanged = channelIdList, }); }); return(new GetResult { Channel = cascade }); }
public async Task <ActionResult <UploadVideoResult> > UploadVideo([FromQuery] SiteRequest request, [FromForm] IFormFile file) { var site = await _siteRepository.GetAsync(request.SiteId); if (file == null) { return(new UploadVideoResult { Error = Constants.ErrorUpload }); } var original = Path.GetFileName(file.FileName); var fileName = _pathManager.GetUploadFileName(site, original); if (!_pathManager.IsVideoExtensionAllowed(site, PathUtils.GetExtension(fileName))) { return(new UploadVideoResult { Error = Constants.ErrorVideoExtensionAllowed }); } if (!_pathManager.IsVideoSizeAllowed(site, file.Length)) { return(new UploadVideoResult { Error = Constants.ErrorVideoSizeAllowed }); } var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Video); var filePath = PathUtils.Combine(localDirectoryPath, fileName); await _pathManager.UploadAsync(file, filePath); var fileUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true); return(new UploadVideoResult { State = "SUCCESS", Url = fileUrl, Title = original, Original = original, Error = null }); }
public async Task <ActionResult <GetResult> > Get([FromQuery] SiteRequest request) { if (!await _authManager.HasAppPermissionsAsync(MenuUtils.AppPermissions.SettingsSites)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); var templateDir = "T_" + site.SiteName.Replace(" ", "_"); return(new GetResult { Site = site, TemplateDir = templateDir }); }
public async Task <ActionResult <UploadResult> > Upload([FromQuery] SiteRequest request, [FromForm] IFormFile file) { var siteIds = await _authManager.GetSiteIdsAsync(); if (!ListUtils.Contains(siteIds, request.SiteId)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (file == null) { return(this.Error(Constants.ErrorUpload)); } var fileName = PathUtils.GetFileName(file.FileName); var extName = PathUtils.GetExtension(fileName); if (!_pathManager.IsImageExtensionAllowed(site, extName)) { return(this.Error(Constants.ErrorImageExtensionAllowed)); } if (!_pathManager.IsImageSizeAllowed(site, file.Length)) { return(this.Error(Constants.ErrorImageSizeAllowed)); } var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Image); var filePath = PathUtils.Combine(localDirectoryPath, _pathManager.GetUploadFileName(site, fileName)); await _pathManager.UploadAsync(file, filePath); await _pathManager.AddWaterMarkAsync(site, filePath); var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true); return(new UploadResult { Name = fileName, Path = filePath, Url = imageUrl }); }
public async Task <ActionResult <GetResult> > Get([FromQuery] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.SettingsContent)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); var isCensorTextEnabled = await _censorManager.IsTextEnabledAsync(); return(new GetResult { Site = site, IsCensorTextEnabled = isCensorTextEnabled }); }
public async Task <ActionResult <IntResult> > Cache([FromBody] SiteRequest request) { var site = await _siteRepository.GetAsync(request.SiteId); await _channelRepository.CacheAllAsync(site); var channelSummaries = await _channelRepository.GetSummariesAsync(site.Id); await _contentRepository.CacheAllListAndCountAsync(site, channelSummaries); await _contentRepository.CacheAllEntityAsync(site, channelSummaries); return(new IntResult { Value = channelSummaries.Count }); }
public async Task <ActionResult <Options> > Get([FromQuery] SiteRequest request) { var site = await _siteRepository.GetAsync(request.SiteId); if (site == null) { return(this.Error("无法确定内容对应的站点")); } var options = TranslateUtils.JsonDeserialize(site.Get <string>(nameof(LayerFileUploadController)), new Options { IsChangeFileName = true, IsLibrary = true, }); return(options); }
public async Task <ActionResult <StringResult> > Export([FromBody] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.SettingsStyleSite)) { return(Unauthorized()); } var fileName = await ExportObject.ExportRootSingleTableStyleAsync(_pathManager, _databaseManager, request.SiteId, _siteRepository.TableName, _tableStyleRepository.GetRelatedIdentities(request.SiteId)); var filePath = _pathManager.GetTemporaryFilesPath(fileName); var downloadUrl = _pathManager.GetRootUrlByPath(filePath); return(new StringResult { Value = downloadUrl }); }
public async Task <ActionResult <ListResult> > List([FromQuery] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.Specials)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); var specials = await _specialRepository.GetSpecialsAsync(request.SiteId); return(new ListResult { Specials = specials, SiteUrl = await _pathManager.GetSiteUrlAsync(site, true) }); }
public IEnumerable <SiteContent> GetParentPages(int siteId, int excludeId = 0) { var request = new SiteRequest() { IncludeSiteContents = true, SiteID = siteId }; var site = GetSite(request); var contents = site.SiteContents.Where(s => s.SiteContentTypeID != (int)ContentType.File && s.SiteContentStatusID != (int)ContentStatus.Removed).ToList(); if (excludeId > 0) { return(contents.GetPotentialParentPages(excludeId)); } return(contents.OrderByHierarchy()); }
public async Task <ActionResult <StringResult> > Export([FromBody] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, Types.SitePermissions.SettingsStyleRelatedField)) { return(Unauthorized()); } var fileName = await ExportObject.ExportRelatedFieldListAsync(_pathManager, _databaseManager, request.SiteId); var filePath = _pathManager.GetTemporaryFilesPath(fileName); var downloadUrl = _pathManager.GetRootUrlByPath(filePath); return(new StringResult { Value = downloadUrl }); }
public static IForm <SiteRequestOrder> BuildForm() { OnCompletionAsyncDelegate <SiteRequestOrder> wrapUpRequest = async(context, request) => { try { SiteRequest siteRquest = new SiteRequest(); siteRquest.ParentSiteUrl = request.ParentSiteUrl; siteRquest.Title = request.Title; siteRquest.Description = request.Description; siteRquest.URLName = request.URLName; siteRquest.Template = Common.GetDescription(request.Template);; string wrapUpMessage = Helper.ProcessRequest.createSubSite(siteRquest); await context.PostAsync(wrapUpMessage); } catch (FormCanceledException <SiteRequestOrder> e) { string reply; if (e.InnerException == null) { reply = $"You quit on {e.Last}--maybe you can finish next time!"; } else { reply = "There is a problem in creating the sub-site at this moment. Please try again later."; } await context.PostAsync(reply); } }; return(new FormBuilder <SiteRequestOrder>() .Message("Welcome to SPOL Site Request bot!") .Field(nameof(ParentSiteUrl), validate: ParentSiteValidator) .Field(nameof(Title)) .Field(nameof(Description)) .Field(nameof(URLName), validate: SubSiteValidator) .Field(nameof(Template)) .AddRemainingFields() .Confirm("Do you want to submit your sub-site request - {Title}?") .Message("Thanks for submitting a new sub-site!") .OnCompletion(wrapUpRequest) .Build()); }
public async Task <ActionResult <UploadResult> > Upload([FromQuery] SiteRequest request, [FromForm] IFormFile file) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, AdvertisementUtils.PermissionsAdd)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (file == null) { return(this.Error("请选择有效的文件上传!")); } var fileName = Path.GetFileName(file.FileName); var fileExtName = PathUtils.GetExtension(fileName).ToLower(); var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, fileExtName); var localFileName = _pathManager.GetUploadFileName(site, fileName); var filePath = PathUtils.Combine(localDirectoryPath, localFileName); if (!_pathManager.IsImageExtensionAllowed(site, fileExtName)) { return(this.Error("此图片格式已被禁止上传,请转换格式后上传!")); } if (!_pathManager.IsImageSizeAllowed(site, file.Length)) { return(this.Error("此图片大小已超过限制,请压缩后上传!")); } await _pathManager.UploadAsync(file, filePath); var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true); var(width, height) = _pathManager.GetImageSize(filePath); return(new UploadResult { ImageUrl = imageUrl, Width = width, Height = height }); }
public async Task <ActionResult <GetResult> > Get([FromQuery] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, BlockManager.PermissionsSettings)) { return(Unauthorized()); } var rules = await _ruleRepository.GetAllAsync(request.SiteId); foreach (var rule in rules) { rule.Set("channels", await GetChannelsAsync(request.SiteId, rule)); } return(new GetResult { Rules = rules }); }
public async Task <ActionResult <UploadResult> > Upload([FromQuery] SiteRequest request, [FromForm] IFormFile file) { if (!await _authManager.HasChannelPermissionsAsync(request.SiteId, request.SiteId, MenuUtils.SitePermissions.SettingsWaterMark)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (file == null) { return(this.Error(Constants.ErrorUpload)); } var fileName = Path.GetFileName(file.FileName); var fileExtName = StringUtils.ToLower(PathUtils.GetExtension(fileName)); var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, fileExtName); var localFileName = _pathManager.GetUploadFileName(site, fileName); var filePath = PathUtils.Combine(localDirectoryPath, localFileName); if (!_pathManager.IsImageExtensionAllowed(site, fileExtName)) { return(this.Error(Constants.ErrorImageExtensionAllowed)); } if (!_pathManager.IsImageSizeAllowed(site, file.Length)) { return(this.Error(Constants.ErrorImageSizeAllowed)); } await _pathManager.UploadAsync(file, filePath); var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true); var virtualUrl = _pathManager.GetVirtualUrl(site, imageUrl); return(new UploadResult { ImageUrl = imageUrl, VirtualUrl = virtualUrl }); }
public async Task <ActionResult <GetResult> > Get([FromQuery] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.SettingsWaterMark)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); var families = FontUtils.GetFontFamilies(); var imageUrl = await _pathManager.ParseSiteUrlAsync(site, site.WaterMarkImagePath, true); return(new GetResult { Site = site, Families = families, ImageUrl = imageUrl }); }
public async Task <ActionResult <UploadResult> > Upload([FromQuery] SiteRequest request, [FromForm] IFormFile file) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.MaterialImage)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (file == null) { return(this.Error(Constants.ErrorUpload)); } var fileName = Path.GetFileName(file.FileName); var extName = PathUtils.GetExtension(fileName); if (!_pathManager.IsImageExtensionAllowed(site, extName)) { return(this.Error(Constants.ErrorImageExtensionAllowed)); } if (!_pathManager.IsImageSizeAllowed(site, file.Length)) { return(this.Error(Constants.ErrorImageSizeAllowed)); } var virtualUrl = PathUtils.GetMaterialVirtualFilePath(UploadType.Image, _pathManager.GetUploadFileName(site, fileName)); var filePath = PathUtils.Combine(_settingsManager.WebRootPath, virtualUrl); await _pathManager.UploadAsync(file, filePath); await _pathManager.AddWaterMarkAsync(site, filePath); return(new UploadResult { Name = fileName, Path = filePath, Url = virtualUrl }); }
public async Task <ActionResult <ConfigResult> > GetConfig([FromQuery] SiteRequest request) { var site = await _siteRepository.GetAsync(request.SiteId); return(new ConfigResult { ImageActionName = "uploadImage", ImageFieldName = "file", ImageMaxSize = site.ImageUploadTypeMaxSize * 1024, ImageAllowFiles = ListUtils.GetStringList(site.ImageUploadExtensions), ImageCompressEnable = false, ImageCompressBorder = 1600, ImageInsertAlign = "none", ImageUrlPrefix = "", ImagePathFormat = "", ScrawlActionName = "uploadScrawl", ScrawlFieldName = "file", ScrawlPathFormat = "", ScrawlMaxSize = site.ImageUploadTypeMaxSize * 1024, ScrawlUrlPrefix = "", ScrawlInsertAlign = "none", VideoActionName = "uploadVideo", VideoFieldName = "file", VideoUrlPrefix = "", VideoMaxSize = site.VideoUploadTypeMaxSize * 1024, VideoAllowFiles = ListUtils.GetStringList(site.VideoUploadExtensions), FileActionName = "uploadFile", FileFieldName = "file", FileUrlPrefix = "", FileMaxSize = site.FileUploadTypeMaxSize * 1024, FileAllowFiles = ListUtils.GetStringList($"{site.ImageUploadExtensions},{site.VideoUploadExtensions},{site.FileUploadExtensions}"), ImageManagerActionName = "listImage", ImageManagerListSize = 20, ImageManagerUrlPrefix = "", ImageManagerInsertAlign = "none", ImageManagerAllowFiles = ListUtils.GetStringList(site.ImageUploadExtensions), FileManagerActionName = "listFile", FileManagerListSize = 20, FileManagerUrlPrefix = "", FileManagerAllowFiles = ListUtils.GetStringList($"{site.ImageUploadExtensions},{site.VideoUploadExtensions},{site.FileUploadExtensions}") }); }
public void Given_a_valid_RegistrationRequest_is_received_when_processed_the_correct_data_is_returned_is_returned_and_UserRepository_is_updated() { //Arrange var sut = InitialiseSiteState(); ErrorMessage error; MockUserPersister.Setup(m => m.TryPersist(ref It.Ref <User> .IsAny, out error)).Callback(new CallbackUser((ref User user, out ErrorMessage errorCallback) => { user.UserId = 0; errorCallback = null; })).Returns(true); var request = new SiteRequest <ISiteData>() { RequestType = RequestType.Create, Payload = TestData.NewUsers.ValidNewUser }; //Act IResponse response; var result = sut.ProcessRequest(request, out response); Assert.IsTrue(result); Assert.IsInstanceOf <RegistrationResponse>(response); var registrationResponse = response as RegistrationResponse; Assert.IsNotNull(registrationResponse); Assert.AreEqual(ResponseResult.Success, registrationResponse?.Result); Assert.AreEqual(nameof(NewUser), registrationResponse.DataType); var dataResponse = registrationResponse.RegistrationForm; Assert.IsNotNull(dataResponse); Assert.IsInstanceOf <NewUser>(dataResponse); Assert.IsNull(dataResponse.Password); Assert.AreEqual(TestData.NewUsers.ValidNewUser, dataResponse); MockUsers.Verify(m => m.Add(It.IsAny <User>()), Times.Once); }
public static SiteInformation ToSiteRequestInformation(SiteRequest request) { var _owner = new SiteUser() { Name = request.PrimaryOwner }; List <SiteUser> _additionalAdmins = new List <SiteUser>(); foreach (var secondaryOwner in request.AdditionalAdministrators) { if (!string.IsNullOrEmpty(secondaryOwner)) { var _sharePointUser = new SiteUser(); _sharePointUser.Name = secondaryOwner; _additionalAdmins.Add(_sharePointUser); } } var _newRequest = new SiteInformation(); _newRequest.Title = request.Title; _newRequest.Description = request.Description; _newRequest.Url = request.Url; _newRequest.TimeZoneId = request.TimeZoneID; _newRequest.Lcid = request.lcid; _newRequest.Template = request.Template; _newRequest.SitePolicy = request.SitePolicy; _newRequest.SiteOwner = _owner; _newRequest.AdditionalAdministrators = _additionalAdmins; _newRequest.SharePointOnPremises = request.SharePointOnPremises; _newRequest.BusinessCase = request.BusinessCase; _newRequest.EnableExternalSharing = request.EnableExternalSharing; if (request.Properties != null) { //Serialize Property Bag Entries _newRequest.SiteMetadataJson = JsonConvert.SerializeObject(request.Properties); } return(_newRequest); }
public async Task <ActionResult <Options> > Get([FromQuery] SiteRequest request) { var site = await _siteRepository.GetAsync(request.SiteId); if (site == null) { return(this.Error("无法确定内容对应的站点")); } var options = TranslateUtils.JsonDeserialize(site.Get <string>(nameof(LayerImageController)), new Options { IsMaterial = true, IsThumb = false, ThumbWidth = 1024, ThumbHeight = 1024, IsLinkToOriginal = true }); return(options); }
public async Task <SiteResponse> Calculate(SiteRequest request) { var response = new SiteResponse { SiteArea = SimpleCalculator.Area(request.Width, request.Length), SitePerimeter = SimpleCalculator.Perimeter(request.Width, request.Length) }; if (request.SiteConfiguration is SubDivisionConfiguration siteConfiguration) { var numberOfLots = SimpleCalculator.NumberOfLots(response.SiteArea, siteConfiguration.SiteCoverage, siteConfiguration.AvgLotSize); response.SiteConfigurationResponse = new SubDivisionResponse { NumberOfLots = numberOfLots }; } return(await Task.FromResult(response)); }
public async Task <ActionResult <SubmitResult> > Submit([FromBody] SiteRequest request) { var site = await _siteRepository.GetAsync(request.SiteId); var channel = await _channelRepository.GetAsync(site.Id); var root = await _channelRepository.GetCascadeAsync(site, channel, async summary => { var count = await _contentRepository.GetCountAsync(site, summary); return(new { Count = count }); }); return(new SubmitResult { Root = root }); }
public async Task <ActionResult <UploadResult> > UploadVideo([FromQuery] SiteRequest request, [FromForm] IFormFile file) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.MaterialVideo)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (file == null) { return(this.Error(Constants.ErrorUpload)); } var fileName = Path.GetFileName(file.FileName); if (!_pathManager.IsVideoExtensionAllowed(site, PathUtils.GetExtension(fileName))) { return(this.Error(Constants.ErrorVideoExtensionAllowed)); } if (!_pathManager.IsVideoSizeAllowed(site, file.Length)) { return(this.Error(Constants.ErrorVideoSizeAllowed)); } var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.Video); var filePath = PathUtils.Combine(localDirectoryPath, _pathManager.GetUploadFileName(site, fileName)); await _pathManager.UploadAsync(file, filePath); var imageUrl = await _pathManager.GetSiteUrlByPhysicalPathAsync(site, filePath, true); return(new UploadResult { Name = fileName, Path = filePath, Url = imageUrl }); }
public async Task <ActionResult <GetResult> > Get([FromQuery] SiteRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, ShareManager.PermissionsSiteShare)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); var siteUrl = await _pathManager.GetSiteUrlAsync(site, true); var ipAddress = PageUtils.GetIpAddress(Request); var settings = await _shareManager.GetSettingsAsync(request.SiteId); return(new GetResult { SiteUrl = siteUrl, IpAddress = ipAddress, Settings = settings }); }
public async Task <ActionResult <GetChannelsResult> > GetChannels([FromQuery] SiteRequest request) { var channels = new List <object>(); var channelIdList = await _authManager.GetChannelIdsAsync(request.SiteId, Types.ContentPermissions.Add); foreach (var permissionChannelId in channelIdList) { var permissionChannelInfo = await _channelRepository.GetAsync(permissionChannelId); channels.Add(new { permissionChannelInfo.Id, ChannelName = await _channelRepository.GetChannelNameNavigationAsync(request.SiteId, permissionChannelId) }); } return(new GetChannelsResult { Channels = channels }); }
/// <summary> /// Adds a new Site /// </summary> /// <param name="newSite"> The Site to be added </param> /// <param name="format"> The format of the Response </param> /// <returns> The SiteResponse object that corresponds to the newly-added Site </returns> public SiteResponse AddSite(SiteRequest newSite, string format = ContentFormat.XML) { return _service.Post<SiteRequest, SiteResponse>(string.Format("{0}/{1}", _gatewayURL, format), newSite); }
/// <summary> /// Updates an existing Site /// </summary> /// <param name="updatedSite">The Site to be updated</param> /// <param name="siteId">The site id.</param> /// <param name="format">The format of the Response</param> /// <returns> /// The SiteResponse object that corresponds to the newly-updated Site /// </returns> public SiteResponse UpdateSite(SiteRequest updatedSite, string siteId, string format = ContentFormat.XML) { return _service.Put<SiteRequest, SiteResponse>(string.Format("{0}/{1}.{2}", _gatewayURL, siteId, format), updatedSite); }