示例#1
0
 private SiteResponse AddSite()
 {
     var newSite = new SiteRequest
     {
         IsTestMode = true,
         Name = TEST_SITE,
         Subdomain = TEST_SITE,
     };
     return _gateway.Sites.AddSite(newSite);
 }
示例#2
0
        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
            });
        }
示例#3
0
        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
            });
        }
示例#8
0
        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
            });
        }
示例#9
0
        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
            });
        }
示例#11
0
        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);
        }
示例#13
0
        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
            });
        }
示例#14
0
        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)
            });
        }
示例#15
0
        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());
        }
示例#16
0
        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
            });
        }
示例#17
0
        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());
        }
示例#18
0
        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
            });
        }
示例#19
0
        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
            });
        }
示例#23
0
        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);
        }
示例#25
0
        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);
        }
示例#26
0
        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);
        }
示例#27
0
        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));
        }
示例#28
0
        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
            });
        }
示例#30
0
        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
            });
        }
示例#32
0
 /// <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);
 }
示例#33
0
 /// <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);
 }