/// <summary> /// Private method to create a content object from a DocumentDto, which is used by Get and GetByVersion. /// </summary> /// <param name="dto"></param> /// <param name="contentType"></param> /// <param name="template"></param> /// <param name="propCollection"></param> /// <returns></returns> private IContent CreateContentFromDto(DocumentDto dto, IContentType contentType, ITemplate template, Models.PropertyCollection propCollection) { var factory = new ContentFactory(contentType, NodeObjectTypeId, dto.NodeId); var content = factory.BuildEntity(dto); //Check if template id is set on DocumentDto, and get ITemplate if it is. if (dto.TemplateId.HasValue && dto.TemplateId.Value > 0) { content.Template = template ?? _templateRepository.Get(dto.TemplateId.Value); } else { //ensure there isn't one set. content.Template = null; } content.Properties = propCollection; //on initial construction we don't want to have dirty properties tracked // http://issues.umbraco.org/issue/U4-1946 ((Entity)content).ResetDirtyProperties(false); return(content); }
/// <summary> /// Gets a <see cref="ITemplate"/> object by its alias. /// </summary> /// <param name="alias">The alias of the template.</param> /// <returns>The <see cref="ITemplate"/> object matching the alias, or null.</returns> public ITemplate GetTemplate(string alias) { using (var scope = ScopeProvider.CreateScope(autoComplete: true)) { return(_templateRepository.Get(alias)); } }
public void Can_Perform_Delete_View() { // Arrange IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { ITemplateRepository repository = CreateRepository(provider); var template = new Template(ShortStringHelper, "test", "test") { Content = "mock-content" }; repository.Save(template); // Act ITemplate templates = repository.Get("test"); Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True); repository.Delete(templates); // Assert Assert.IsNull(repository.Get("test")); Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.False); } }
public List <Template> GetTemplates(string clientID) { try { return(_repository.Get(t => t.ClientID == clientID) .ToList()); } catch (Exception ex) { throw ex; } }
public ActionResult <Result <bool> > UpdateModel([FromBody] UpdateTemplateModelRQ body) { var templateEntity = _templateRepo.Get(body.Id); var scriptExeRes = _microsoftSQLService.ExecuteSQLAsAdmin(body.SqlScript, templateEntity.NameOnServer); if (scriptExeRes.Messages.Any()) { return(Result <bool> .Fail(scriptExeRes.Messages)); } return(Result <bool> .Success(true)); }
public IActionResult Model(int templateId) { var templateEntity = _templateRepo.Get(templateId); var vm = new TemplateModelVM() //AutoMapper { Id = templateEntity.Id, TimeStamp = Convert.ToBase64String(templateEntity.TimeStamp), TemplateName = templateEntity.Name, DatabaseName = templateEntity.NameOnServer }; return(View(vm)); }
public ActionResult <Result <bool> > CreateInstance([FromBody] CreateExerciseInstanceRQ body) { #region Map_User var isUserMapped = _userRepo.IsMapped(UserId); if (!isUserMapped) { var sqlUsername = NameHelper.GenerateSqlUserName(UserId); var sqlPass = NameHelper.GenerateRandomSqlPassowrd(); var mapSaveSuccess = _userRepo.CreateMapping(UserId, sqlUsername, sqlPass, UserId); if (!mapSaveSuccess) { return(Result <bool> .Fail("Error mapping user.")); } } var userMapEntity = _userRepo.Get(UserId); #endregion #region Check_Name var exerciseExists = _exerciseRepo.NameExists(body.Name, UserId); if (exerciseExists) { return(Result <bool> .Fail($"Instance '{body.Name}' already exists.")); } #endregion #region Clone_DB var nameOnServer = NameHelper.ExerciseName(); var templateEntity = _templateRepo.Get(body.TemplateId); var cloneSuccess = _msSqlService.CloneDatabase(templateEntity.NameOnServer, nameOnServer, false, true); if (!cloneSuccess) { return(Result <bool> .Fail("Failed to clone database.")); } #endregion #region Create_DB_User var createSuccess = _msSqlService.CreateDbUserContained(userMapEntity.SqlUsername, userMapEntity.SqlPassword, nameOnServer); if (!createSuccess) { return(Result <bool> .Fail("Failed to create database user.")); } var assignSuccess = _msSqlService.AssignCRUD(userMapEntity.SqlUsername, nameOnServer); if (!assignSuccess) { return(Result <bool> .Fail("Failed to assign database user permissions.")); } #endregion #region Save_Record var saveSuccess = _exerciseRepo.Create(body.TemplateId, UserId, body.Name, nameOnServer, UserId); if (!saveSuccess) { return(Result <bool> .Fail("Failed to save record.")); } #endregion return(Result <bool> .Success(true)); }
public void Can_Perform_Update_View() { // Arrange IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { ITemplateRepository repository = CreateRepository(provider); // Act var template = new Template(ShortStringHelper, "test", "test") { Content = "mock-content" }; repository.Save(template); template.Content += "<html></html>"; repository.Save(template); ITemplate updated = repository.Get("test"); // Assert Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True); Assert.That(updated.Content, Is.EqualTo("mock-content" + "<html></html>")); } }
public void SendActivationRequest(ActivationRequest activationRequest) { Template activationTemplate = _templateRepository.Get("ActivationTemplate.html"); string notification = activationTemplate.Apply(activationRequest.ToDictionary()); _notificationSender.SendNotification(notification, activationRequest.Email.Value); }
public async Task <IActionResult> OnPostCreateTemplateVersion() { // TODO: Error handling TemplateTbl?template = (await _templateTbl.Get(x => x.Id.Equals(CreateTemplateVersion.TemplateId), null, nameof(TemplateTbl.Versions))).FirstOrDefault(); if (template == null) { throw new NullReferenceException(); } CreateTemplateVersion.Name = "Untitled name"; CreateTemplateVersion.Subject = "Default subject"; CreateTemplateVersion.Html = string.Empty; CreateTemplateVersion.TestData = "{}"; if (!template.Versions?.Any() ?? true) { CreateTemplateVersion.IsActive = true; } TemplateVersionTbl result = await _templateVersionTbl.Add(CreateTemplateVersion); await _projectTbl.UpdateFromQuery(x => x.Id.Equals(MarkAsActive.ProjectId), _ => new ProjectTbl { DateModified = DateTime.Now }); TempData["toastStatus"] = "success"; TempData["toastMessage"] = "Template version created"; TempData["scrollToId"] = $"version-{result.Id}"; return(RedirectToPage("/Project/Details", new { id = template.ProjectId })); }
public void Can_Perform_Add_View_With_Default_Content_With_Parent() { // Arrange IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { ITemplateRepository repository = CreateRepository(provider); // NOTE: This has to be persisted first var template = new Template(ShortStringHelper, "test", "test"); repository.Save(template); // Act var template2 = new Template(ShortStringHelper, "test2", "test2"); template2.SetMasterTemplate(template); repository.Save(template2); // Assert Assert.That(repository.Get("test2"), Is.Not.Null); Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test2.cshtml"), Is.True); Assert.AreEqual( "@usingUmbraco.Cms.Web.Common.PublishedModels;@inherits Umbraco.Cms.Web.Common.Views.UmbracoViewPage @{ Layout = \"test.cshtml\";}".StripWhitespace(), template2.Content.StripWhitespace()); } }
private string CreateDefaultMasterPageContent(ITemplate template, ITemplateRepository templateRepo) { var design = new StringBuilder(); design.Append(GetMasterPageHeader(template) + Environment.NewLine); if (template.MasterTemplateAlias.IsNullOrWhiteSpace() == false) { var master = templateRepo.Get(template.MasterTemplateAlias); if (master != null) { foreach (var cpId in GetContentPlaceholderIds(master)) { design.Append("<asp:content ContentPlaceHolderId=\"" + cpId + "\" runat=\"server\">" + Environment.NewLine + Environment.NewLine + "</asp:content>" + Environment.NewLine + Environment.NewLine); } return(design.ToString()); } } design.Append(GetMasterContentElement(template) + Environment.NewLine); design.Append(template.Content + Environment.NewLine); design.Append("</asp:Content>" + Environment.NewLine); return(design.ToString()); }
public void Can_Perform_Delete_When_Assigned_To_Doc() { // Arrange IScopeProvider provider = ScopeProvider; var scopeAccessor = (IScopeAccessor)provider; IDataTypeService dataTypeService = GetRequiredService <IDataTypeService>(); IFileService fileService = GetRequiredService <IFileService>(); using (provider.CreateScope()) { ITemplateRepository templateRepository = CreateRepository(provider); var globalSettings = new GlobalSettings(); var serializer = new JsonNetSerializer(); var tagRepository = new TagRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <TagRepository>()); var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, AppCaches, ShortStringHelper); var languageRepository = new LanguageRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <LanguageRepository>(), Microsoft.Extensions.Options.Options.Create(globalSettings)); var contentTypeRepository = new ContentTypeRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <ContentTypeRepository>(), commonRepository, languageRepository, ShortStringHelper); var relationTypeRepository = new RelationTypeRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <RelationTypeRepository>()); var entityRepository = new EntityRepository(scopeAccessor, AppCaches.Disabled); var relationRepository = new RelationRepository(scopeAccessor, LoggerFactory.CreateLogger <RelationRepository>(), relationTypeRepository, entityRepository); var propertyEditors = new PropertyEditorCollection(new DataEditorCollection(() => Enumerable.Empty <IDataEditor>())); var dataValueReferences = new DataValueReferenceFactoryCollection(() => Enumerable.Empty <IDataValueReferenceFactory>()); var contentRepo = new DocumentRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <DocumentRepository>(), LoggerFactory, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors, dataValueReferences, dataTypeService, serializer, Mock.Of <IEventAggregator>()); Template template = TemplateBuilder.CreateTextPageTemplate(); fileService.SaveTemplate(template); // else, FK violation on contentType! ContentType contentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage2", "Textpage", defaultTemplateId: template.Id); contentTypeRepository.Save(contentType); Content textpage = ContentBuilder.CreateSimpleContent(contentType); contentRepo.Save(textpage); textpage.TemplateId = template.Id; contentRepo.Save(textpage); // Act ITemplate templates = templateRepository.Get("textPage"); templateRepository.Delete(templates); // Assert Assert.IsNull(templateRepository.Get("textPage")); } }
public ActionResult <Result <bool> > CreateTask([FromBody] CreateTaskRQ body) { if (string.IsNullOrEmpty(body.Name)) { return(Result <bool> .Fail("Name cannot be empty.")); } if (body.TemplateId <= 0) { return(Result <bool> .Fail("A template must be selected.")); } var taskExists = _taskRepo.TaskExists(body.Name); if (taskExists) { return(Result <bool> .Fail($"Task '{body.Name}' already exists.")); } var newDbName = NameHelper.TaskName(); var alreadyRegistered = _taskRepo.DatabaseRegisteredAsTask(newDbName); if (alreadyRegistered) { return(Result <bool> .Fail($"Generated name is already used for another task. Please try again.")); } var existsOnSqlServer = _microsoftSQLService.DatabaseExists(newDbName); if (existsOnSqlServer) { return(Result <bool> .Fail($"Generated name is not unique. Please try again.")); } var templateEntity = _templateRepo.Get(body.TemplateId); var cloneSuccess = _microsoftSQLService.CloneDatabase(templateEntity.NameOnServer, newDbName, true, true); if (!cloneSuccess) { return(Result <bool> .Fail($"Failed to clone database '{templateEntity.NameOnServer}' into '{newDbName}'.")); } var success = _taskRepo.Create(body, newDbName, UserId); if (success) { return(Result <bool> .Success(true)); } else { return(Result <bool> .Fail("Failed to save changes.")); } }
public void Can_Perform_Delete_On_Nested_Templates() { // Arrange IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { ITemplateRepository repository = CreateRepository(provider); var parent = new Template(ShortStringHelper, "parent", "parent") { Content = @"<%@ Master Language=""C#"" %>" }; var child = new Template(ShortStringHelper, "child", "child") { Content = @"<%@ Master Language=""C#"" %>" }; var baby = new Template(ShortStringHelper, "baby", "baby") { Content = @"<%@ Master Language=""C#"" %>" }; child.MasterTemplateAlias = parent.Alias; child.MasterTemplateId = new Lazy <int>(() => parent.Id); baby.MasterTemplateAlias = child.Alias; baby.MasterTemplateId = new Lazy <int>(() => child.Id); repository.Save(parent); repository.Save(child); repository.Save(baby); // Act ITemplate templates = repository.Get("parent"); repository.Delete(templates); // Assert Assert.IsNull(repository.Get("test")); } }
public void Can_Perform_Add_View() { // Arrange IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { ITemplateRepository repository = CreateRepository(provider); // Act var template = new Template(ShortStringHelper, "test", "test"); repository.Save(template); // Assert Assert.That(repository.Get("test"), Is.Not.Null); Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True); } }
/// <summary> /// Private method to create a content object from a DocumentDto, which is used by Get and GetByVersion. /// </summary> /// <param name="dto"></param> /// <param name="versionId"></param> /// <returns></returns> private IContent CreateContentFromDto(DocumentDto dto, Guid versionId) { var contentType = _contentTypeRepository.Get(dto.ContentVersionDto.ContentDto.ContentTypeId); var factory = new ContentFactory(contentType, NodeObjectTypeId, dto.NodeId); var content = factory.BuildEntity(dto); //Check if template id is set on DocumentDto, and get ITemplate if it is. if (dto.TemplateId.HasValue && dto.TemplateId.Value > 0) { content.Template = _templateRepository.Get(dto.TemplateId.Value); } content.Properties = GetPropertyCollection(dto.NodeId, versionId, contentType, content.CreateDate, content.UpdateDate); ((ICanBeDirty)content).ResetDirtyProperties(); return(content); }
protected override IContentType PerformGet(int id) { var contentTypeSql = GetBaseQuery(false); contentTypeSql.Where(GetBaseWhereClause(), new { Id = id }); // The SQL will contain one record for each allowed template, so order to put the default one // at the top to populate the default template property correctly. contentTypeSql.OrderByDescending <DocumentTypeDto>(x => x.IsDefault); var dto = Database.Fetch <DocumentTypeDto, ContentTypeDto, NodeDto>(contentTypeSql).FirstOrDefault(); if (dto == null) { return(null); } var factory = new ContentTypeFactory(NodeObjectTypeId); var contentType = factory.BuildEntity(dto); contentType.AllowedContentTypes = GetAllowedContentTypeIds(id); contentType.PropertyGroups = GetPropertyGroupCollection(id, contentType.CreateDate, contentType.UpdateDate); ((ContentType)contentType).PropertyTypes = GetPropertyTypeCollection(id, contentType.CreateDate, contentType.UpdateDate); var templates = Database.Fetch <DocumentTypeDto>("WHERE contentTypeNodeId = @Id", new { Id = id }); if (templates.Any()) { contentType.AllowedTemplates = templates.Select(template => _templateRepository.Get(template.TemplateNodeId)).ToList(); } var list = Database.Fetch <ContentType2ContentTypeDto>("WHERE childContentTypeId = @Id", new { Id = id }); foreach (var contentTypeDto in list) { bool result = contentType.AddContentType(Get(contentTypeDto.ParentId)); //Do something if adding fails? (Should hopefully not be possible unless someone created a circular reference) } //on initial construction we don't want to have dirty properties tracked // http://issues.umbraco.org/issue/U4-1946 ((Entity)contentType).ResetDirtyProperties(false); return(contentType); }
/// <summary> /// Private method to create a content object from a DocumentDto, which is used by Get and GetByVersion. /// </summary> /// <param name="dto"></param> /// <param name="versionId"></param> /// <returns></returns> private IContent CreateContentFromDto(DocumentDto dto, Guid versionId) { var contentType = _contentTypeRepository.Get(dto.ContentVersionDto.ContentDto.ContentTypeId); var factory = new ContentFactory(contentType, NodeObjectTypeId, dto.NodeId); var content = factory.BuildEntity(dto); //Check if template id is set on DocumentDto, and get ITemplate if it is. if (dto.TemplateId.HasValue && dto.TemplateId.Value > 0) { content.Template = _templateRepository.Get(dto.TemplateId.Value); } content.Properties = GetPropertyCollection(dto.NodeId, versionId, contentType, content.CreateDate, content.UpdateDate); //on initial construction we don't want to have dirty properties tracked // http://issues.umbraco.org/issue/U4-1946 ((Entity)content).ResetDirtyProperties(false); return(content); }
public async Task <IActionResult> Get(string type, string year) { if (!ReportType.Values().Contains(type)) { return(new BadRequestObjectResult(new ErrorResponse($"Invalid ReportType '{type}'."))); } var template = await Task.Run(() => _templates.Get(ReportType.FromString(type), year)); if (template == null) { return(NotFound()); } var stream = new MemoryStream(template.Content); return(new FileStreamResult(stream, ContentTypes.XLSX) { FileDownloadName = template.Name, }); }
public void Can_Perform_Add_View_With_Default_Content() { // Arrange IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { ITemplateRepository repository = CreateRepository(provider); // Act var template = new Template(ShortStringHelper, "test", "test") { Content = "mock-content" }; repository.Save(template); // Assert Assert.That(repository.Get("test"), Is.Not.Null); Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True); Assert.AreEqual("mock-content", template.Content.StripWhitespace()); } }
public void Can_Perform_Add_View_With_Default_Content() { // Arrange IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { ITemplateRepository repository = CreateRepository(provider); // Act var template = new Template(ShortStringHelper, "test", "test") { Content = ViewHelper.GetDefaultFileContent() }; repository.Save(template); // Assert Assert.That(repository.Get("test"), Is.Not.Null); Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True); Assert.AreEqual( @"@usingUmbraco.Cms.Web.Common.PublishedModels;@inheritsUmbraco.Cms.Web.Common.Views.UmbracoViewPage@{Layout=null;}".StripWhitespace(), template.Content.StripWhitespace()); } }
public T Get(Guid id) { return(_repo.Get(id)); }
public async Task <Template> Get(string id) => await _templates.Get(id);
public async Task <Result <IList <Tuple <string, string> > > > Execute(string userId, Guid templateId) { var template = await _templateRepository.Get(templateId); if (template.UserId != userId) { return(Result <IList <Tuple <string, string> > > .Fail($"Attempt to execute non-existing template '{templateId}'")); } var dataSource = await _dataSourceRepository.FindAsync(template.DataSourceId, true); var samples = new[] { template.KeySelector.ReturnValue, template.DataSourceFilter.LeftVal, template.MapFunction.ReturnValue }; var commonPrefix = new string( samples.First().Substring(0, samples.Min(s => s.Length)) .TakeWhile((c, i) => samples.All(s => s[i] == c)).ToArray()); var leftValWithoutPrefix = template.DataSourceFilter.LeftVal.Substring(commonPrefix.Length); var keySelectorWithoutPrefix = template.KeySelector.ReturnValue.Substring(commonPrefix.Length); var mapFunctionWithoutPrefix = template.MapFunction.ReturnValue.Substring(commonPrefix.Length); var leftValComponents = leftValWithoutPrefix.Split('.'); var finalComponent = leftValComponents.Last(); var leftValComponentsWithoutFinalComponent = leftValComponents.Take(leftValComponents.Length - 1).ToList(); var rightVal = template.DataSourceFilter.RightVal; var dataType = dataSource.Schema.Single(x => x.FullName == template.DataSourceFilter.LeftVal); if (dataType.Origin == DataTypeOrigin.Attribute) { finalComponent = $"@{finalComponent}"; } if (dataType.DataType == "string") { rightVal = $"'{rightVal}'"; } var dataSourceFilterQueryBuilder = new StringBuilder() .Append("/") .Append(string.Join("/", commonPrefix.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries))) .Append("[") .Append(string.Join("/", leftValComponentsWithoutFinalComponent)); if (leftValComponentsWithoutFinalComponent.Any()) { dataSourceFilterQueryBuilder.Append("/"); } var dataSourceFilterQuery = dataSourceFilterQueryBuilder .Append(finalComponent) .Append(template.DataSourceFilter.Comparator) .Append(rightVal) .Append("]") .ToString(); var keySelectorQuery = new StringBuilder() .Append("./") .Append(string.Join("/", keySelectorWithoutPrefix.Split('.'))) .ToString(); var mapFunctionQuery = new StringBuilder() .Append("./") .Append(string.Join("/", mapFunctionWithoutPrefix.Split('.'))) .ToString(); var ms = new MemoryStream(dataSource.Value, 0, dataSource.Value.Length); var xDoc = new XmlDocument(); xDoc.Load(ms); var xRoot = xDoc.DocumentElement; var toReturn = new List <Tuple <string, string> >(); if (xRoot is null) { return(toReturn); } // ReSharper disable once PossibleNullReferenceException foreach (var node in xRoot.SelectNodes(dataSourceFilterQuery)) { var xmlNode = (XmlElement)node; var key = xmlNode.SelectSingleNode(keySelectorQuery); var value = xmlNode.SelectSingleNode(mapFunctionQuery); if (key != null && value != null) { toReturn.Add(new Tuple <string, string>(key.InnerText, value.InnerText)); } } return(toReturn); }