public void CreateRepository() { _repo = new UserRepository(); _user1 = new User("admin","test"); _repo.Save(_user1); _user2 = new User("razvan","1234"); _repo.Save(_user2); }
public void CreateRepository() { _repo = new ExpenseRepository(); _exp1 = new Expense(TypeExpense.Car, 34, "euro"); _exp2 = new Expense(TypeExpense.Eat, 45, "euro"); _repo.Save(_exp1); _repo.Save(_exp2); }
public when_implementing_base_repository() { RefreshDb(); _repository = new DataProviderRepository(Session); var dataProvider = ReadDataProviderMother.Ivid; _repository.Save(dataProvider); _repository.Save(ReadDataProviderMother.Rgt); Session.Flush(); _id = GetFromDb(dataProvider).Id; }
public void Common_CanDelete(IRepository<Product> db) { db.Save(new Product { ProductName = "Optimus", Category = "Autobots", MinimumPrice = 7 }); var px = new Product { ProductName = "Bumble Bee", Category = "Autobots", MinimumPrice = 8 }; db.Save(px); db.Save(new Product { ProductName = "Megatron", Category = "Decepticon", MinimumPrice = 9 }); db.Delete(px.ProductId, px.RowVersion); Assert.AreEqual(7 + 9, db.All.Sum(x => x.MinimumPrice)); Assert.AreEqual(null, db.Get(px.ProductId)); Assert.AreEqual(2, db.All.Count()); }
static void Main(string[] args) { IoC.Register(); _repo = IoC.Resolve<IRepository>(); var geos = _repo.Find<City>().ToList(); Console.WriteLine(string.Format("{0} total cities...", geos.Count())); int i =0; foreach (var geo in geos) { if (geo.Geography.GetType() == typeof(NetTopologySuite.Geometries.MultiPoint)) { Console.WriteLine(string.Format("{0} is a MultiPoint...", geo.Name)); var point = new NetTopologySuite.Geometries.Point(geo.Geography.Coordinates.First()); geo.Geography = point; _repo.Save<City>(geo); _repo.SubmitChanges(); Console.WriteLine(string.Format("{0} updated to Point...", geo.Name)); i++; } } Console.WriteLine(string.Format("{0} total Cities updated...", i)); Console.Read(); }
// Update course public static CourseUpdate.Response Handle(IRepository repository, CourseUpdate.Request request) { var container = CourseFactory.CreatePartial(request.CommandModel.CourseID).Modify(request.CommandModel); var validationDetails = repository.Save(container); return new CourseUpdate.Response(validationDetails); }
private static Setting InitializeSetting(string settingName, IRepository repository) { var setting = new Setting { Name = settingName.Encrypt() }; repository.Add<Setting>(setting); repository.Save(); return setting; }
public override void Handle(IRepository _repository) { var command = this; var order = _repository.GetOrder(command.OrderId); var products = order.Products.Add(_repository.GetProduct(command.ProductId)); _repository.Save(order.With(products:products)); }
// Modify student public static StudentModify.Response Handle(IRepository repository, StudentModify.Request request) { var commandModel = request.CommandModel; var container = StudentFactory.CreatePartial(commandModel.ID).Modify(commandModel); var validationDetails = repository.Save(container); return new StudentModify.Response(validationDetails); }
// Delete course public static CourseDelete.Response Handle(IRepository repository, CourseDelete.Request request) { var course = CourseFactory.CreatePartial(request.CommandModel.CourseId); var container = course.Delete(); repository.Save(container); return new CourseDelete.Response(); }
/// <summary>Setups the basic settings.</summary> /// <param name="settingsRepository">The settings repository.</param> private static void SetupSettings(IRepository<Settings> settingsRepository) { var userRegistrationPrice = new Settings { _Key = USER_REGISTRATION_PRICE_KEY, Value = "50" }; var vendorRegistrationPrice = new Settings { _Key = VENDOR_REGISTRATION_PRICE_KEY, Value = "100" }; settingsRepository.Save(userRegistrationPrice); settingsRepository.Save(vendorRegistrationPrice); }
private static void SampleMethod(IRepository<Product,int?> productRepository) { SessionProvider.RebuildSchema(); //Create a Product var pNew = new Product { ProductName = "Canned Salmon" }; productRepository.Save(pNew); //Get a Product var pGet = productRepository.GetById(pNew.ProductId); //Update a Product pGet.ProductName = "Canned Tuna"; productRepository.Save(pGet); //Delete a Product productRepository.Delete(pNew); }
// Delete studen public static StudentDelete.Response Handle(IRepository repository, StudentDelete.Request request) { var container = StudentFactory .CreatePartial(request.CommandModel.StudentId) .Delete(); var validationDetails = repository.Save(container); return new StudentDelete.Response(validationDetails); }
public void SetUp() { _repository = new MockRepository(); _developer = new Developer() { Username = "******" }; _calculators = new[] { new DefaultAchievementCalculator(_repository) }; _repository.Save(_developer); }
public virtual void setup() { var mongoRepository = new MongoRepository("blogspecs"); mongoRepository.DeleteCollection<BlogSettings>(); mongoRepository.DeleteCollection<Post>(); _repository = mongoRepository; _blog = new BlogSettings { VirtualMediaPath = "" }; _repository.Save(_blog); _fakePost = Post.CreatePost("Hello world", "", "BjartN", null); _repository.Save(_fakePost); _api = new Infrastructure.MetaWeblogApi.MetaWeblog(_repository, new FakeUrlContext(),new FakeAuthenticationService()); }
public static CountryCreate.Response Handle(IRepository repository, CountryCreate.Request request) { var validationDetails = Validator.ValidateRequest(request); if (validationDetails.HasValidationIssues) return new CountryCreate.Response(validationDetails: validationDetails); var country = new Country(request.CommandModel.Name, request.CommandModel.Population); repository.Add(country); repository.Save(); return new CountryCreate.Response(country.Id); }
public static void InitializeTestClass(TestContext testContext) { if (Directory.Exists(Configuration.PERSITS_VIRTUAL_FILE_PATH)) { Directory.Delete(Configuration.PERSITS_VIRTUAL_FILE_PATH, true); } Application.Current.SetApplicationAssembly(Assembly.GetExecutingAssembly()); repository = new DefaultRepository(fileStoreService, cacheStoreService); repository.Save(RepositoryTests.GetContentTypeCollection()); }
// Create student public static StudentCreate.Response Handle(IRepository repository, StudentCreate.Request request) { var container = new EntityStateWrapperContainer(); container.AddEntity(StudentFactory.Create(request.CommandModel)); var validationDetails = repository.Save(container); var studentId = default(int?); if (!validationDetails.HasValidationIssues) studentId = container.FindEntity<Student>().ID; return new StudentCreate.Response(validationDetails, studentId); }
// Create Department public static DepartmentCreate.Response Handle(IRepository repository, DepartmentCreate.Request request) { // Validation now performed in the dispacther decorators (See AutoValidate<T> in the DomainBootstrapper class) var container = DepartmentFactory.Create(request.CommandModel); var validationDetails = repository.Save(container); var deptId = default(int?); if (!validationDetails.HasValidationIssues) deptId = container.FindEntity<Department>().DepartmentID; return new DepartmentCreate.Response(validationDetails, deptId); }
// Create course public static CourseCreate.Response Handle(IRepository repository, CourseCreate.Request request) { // Validation now performed in the dispacther decorators (See AutoValidate<T> in the DomainBootstrapper class) var container = new EntityStateWrapperContainer(); container.AddEntity(CourseFactory.Create(request.CommandModel)); var validationDetails = repository.Save(container); var courseId = default(int?); if (!validationDetails.HasValidationIssues) courseId = container.FindEntity<Course>().CourseID; return new CourseCreate.Response(validationDetails, courseId); }
// Modify instructor with course public static InstructorModifyAndCourses.Response Handle(IRepository repository, InstructorModifyAndCourses.Request request) { var commandModel = request.CommandModel; var instructor = repository.GetEntity<Instructor>( p => p.ID == commandModel.InstructorId, new EagerLoadingQueryStrategy<Instructor>( p => p.Courses, p => p.OfficeAssignment)); var container = instructor.Modify(repository, request.CommandModel); var validationDetails = repository.Save(container); return new InstructorModifyAndCourses.Response(validationDetails); }
public void GetContact_ContactExists_ContactReturned( TestIndexUtils contactIndex, IRepository<ElasticContact> repo, ElasticContact contact, ISystemContext ctx) { using (contactIndex) { repo.Save(contact, ctx); var res = repo.Get(contact.Id, ctx); res.Should().NotBeNull(); res.Id.Should().Be(contact.Id); } }
public void GetContact_ContactDoesntExist_ContactNotReturned( TestIndexUtils contactIndex, IRepository<ElasticContact> repo, ElasticContact contact, ISystemContext ctx) { using (contactIndex) { // a little hacky - this is an easy way of ensuring the test index exists first. repo.Save(contact, ctx); var res = repo.Get(new Guid(), ctx); res.Should().BeNull(); } }
static void Main(string[] args) { var builder = new ContainerBuilder(); builder.RegisterType<Customer>().As<ICustomer>(); builder.RegisterType<LineItem>().As<ILineItem>(); builder.RegisterType<Order>().As<IOrder>(); builder.RegisterType<Product>().As<IProduct>(); Container = builder.Build(); _customerRepo = new Repository<Customer>(); _customerRepo.Add(new Customer { FirstName = "Chris", LastName = "Cais" }); _customerRepo.Add(new Customer { FirstName = "James", LastName = "Harden" }); _customerRepo.Save(); }
public virtual void setup() { _savedPosts = new List<Post>(); var mongoRepository = new MongoRepository("blogspecs"); mongoRepository.DeleteCollection<BlogSettings>(); mongoRepository.DeleteCollection<Post>(); _repository = mongoRepository; for (var i = 0; i < 10; i++) { var post = Post.CreatePost("Title" + i, "Body" + i, "BjartN", new List<Tag> {new Tag("tag" + i), new Tag("tag" + (i+1))}); _repository.Save(post); _savedPosts.Add(post); } }
// Delete instructor public static InstructorDelete.Response Handle(IRepository repository, InstructorDelete.Request request) { var container = new EntityStateWrapperContainer(); var depts = repository.GetEntities<Department>(p => p.InstructorID == request.CommandModel.InstructorId); foreach (var dept in depts) container.Add(dept.SetInstructorId(null)); var deletedInstructor = repository.GetEntity<Instructor>( p => p.ID == request.CommandModel.InstructorId, new EagerLoadingQueryStrategy<Instructor>( p => p.OfficeAssignment)); container.Add(deletedInstructor.Delete()); var validationDetails = repository.Save(container); return new InstructorDelete.Response(validationDetails); }
// Update department #region Update department public static DepartmentUpdate.Response Handle(IRepository repository, DepartmentUpdate.Request request) { var validationDetails = Validator.ValidateRequest(request, repository); if (validationDetails.HasValidationIssues) return new DepartmentUpdate.Response(validationDetails); var commandModel = request.CommandModel; var currentDept = repository.GetEntity<Department>( p => p.DepartmentID == commandModel.DepartmentID, new AsNoTrackingQueryStrategy()); var rowVersion = default(byte[]); var container = currentDept.Modify(request.CommandModel); validationDetails = repository.Save(container, dbUpdateEx => OnUpdateFailedFunc(repository, dbUpdateEx, commandModel, ref rowVersion)); return new DepartmentUpdate.Response(validationDetails, rowVersion); }
// Delete Department public static DepartmentDelete.Response Handle(IRepository repository, DepartmentDelete.Request request) { var validationDetails = Validator.ValidateRequest(request, repository); if (validationDetails.HasValidationIssues) return new DepartmentDelete.Response(validationDetails); var department = repository.GetEntity<Department>( p => p.DepartmentID == request.CommandModel.DepartmentID, new EagerLoadingQueryStrategy<Department>( p => p.Administrator)); var hasConcurrencyError = false; var container = department.Delete(); validationDetails = repository.Save(container, dbUpdateConcurrencyExceptionFunc: dbUpdateEx => { hasConcurrencyError = true; return new ValidationMessageCollection(new ValidationMessage(string.Empty, dbUpdateEx.ToString())); }); return new DepartmentDelete.Response(validationDetails, hasConcurrencyError); }
public JsonResult Create(BonusDto bonusDto) { BonusAggregate bonus; if (bonusDto.Amount <= 0) throw new ArgumentOutOfRangeException("Amount should be more than 0"); if (bonusDto.EmployeeId <= 0) throw new ArgumentNullException("You should specify an existing employee"); using (var dbContext = new DatabaseContext()) { BonusesRepository = new BonusesRepository(dbContext); var employeeRepository = new EmployeesRepository(dbContext); bonus = new BonusFactory(employeeRepository).Create(bonusDto); BonusesRepository.Save(bonus); } return Json(bonus); }
/// <summary> /// Deletes the page. /// </summary> /// <param name="model">The model.</param> /// <param name="principal">The principal.</param> /// <param name="messages">The messages.</param> /// <returns> /// Delete result /// </returns> /// <exception cref="ConcurrentDataException"></exception> /// <exception cref="System.ComponentModel.DataAnnotations.ValidationException"> /// </exception> public bool DeletePage(DeletePageViewModel model, IPrincipal principal, IMessagesIndicator messages = null) { var languagesFuture = repository.AsQueryable <Language>().ToFuture(); var page = repository.AsQueryable <PageProperties>(p => p.Id == model.PageId) .FetchMany(p => p.PageContents) .ThenFetch(pc => pc.Content) .ToFuture() .ToList() .FirstOne(); // Unidentified problem where in some cases proxy is returned. if (page is INHibernateProxy) { page = repository.UnProxy(page); } if (model.Version > 0 && page.Version != model.Version) { throw new ConcurrentDataException(page); } if (page.IsMasterPage && repository.AsQueryable <MasterPage>(mp => mp.Master == page).Any()) { var message = PagesGlobalization.DeletePageCommand_MasterPageHasChildren_Message; var logMessage = string.Format("Failed to delete page. Page is selected as master page. Id: {0} Url: {1}", page.Id, page.PageUrl); throw new ValidationException(() => message, logMessage); } var isRedirectInternal = false; if (!string.IsNullOrWhiteSpace(model.RedirectUrl)) { isRedirectInternal = urlService.ValidateInternalUrl(model.RedirectUrl); if (!isRedirectInternal && urlService.ValidateInternalUrl(urlService.FixUrl(model.RedirectUrl))) { isRedirectInternal = true; } if (isRedirectInternal) { model.RedirectUrl = urlService.FixUrl(model.RedirectUrl); } } if (model.UpdateSitemap) { accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.EditContent); } var sitemaps = new Dictionary <Sitemap, bool>(); var sitemapNodes = sitemapService.GetNodesByPage(page); if (model.UpdateSitemap) { sitemapNodes.Select(node => node.Sitemap) .Distinct() .ToList() .ForEach( sitemap => sitemaps.Add( sitemap, !cmsConfiguration.Security.AccessControlEnabled || accessControlService.GetAccessLevel(sitemap, principal) == AccessLevel.ReadWrite)); foreach (var node in sitemapNodes) { if (sitemaps[node.Sitemap] && node.ChildNodes.Count > 0) { var logMessage = string.Format("In {0} sitemap node {1} has {2} child nodes.", node.Sitemap.Id, node.Id, node.ChildNodes.Count); throw new ValidationException(() => PagesGlobalization.DeletePageCommand_SitemapNodeHasChildNodes_Message, logMessage); } } } unitOfWork.BeginTransaction(); // Update sitemap nodes IList <SitemapNode> updatedNodes = new List <SitemapNode>(); IList <SitemapNode> deletedNodes = new List <SitemapNode>(); UpdateSitemapNodes(model, page, sitemapNodes, sitemaps, languagesFuture.ToList(), updatedNodes, deletedNodes); Redirect redirect; if (!string.IsNullOrWhiteSpace(model.RedirectUrl)) { if (string.Equals(page.PageUrl, model.RedirectUrl, StringComparison.OrdinalIgnoreCase)) { var logMessage = string.Format("Circular redirect loop from url {0} to url {0}.", model.RedirectUrl); throw new ValidationException(() => PagesGlobalization.ValidatePageUrlCommand_SameUrlPath_Message, logMessage); } // Validate url if (!urlService.ValidateExternalUrl(model.RedirectUrl)) { var logMessage = string.Format("Invalid redirect url {0}.", model.RedirectUrl); throw new ValidationException(() => PagesGlobalization.ValidatePageUrlCommand_InvalidUrlPath_Message, logMessage); } string patternsValidationMessage; if (isRedirectInternal && !urlService.ValidateUrlPatterns(model.RedirectUrl, out patternsValidationMessage, PagesGlobalization.DeletePage_RedirectUrl_Name)) { var logMessage = string.Format("{0}. URL: {1}.", patternsValidationMessage, model.RedirectUrl); throw new ValidationException(() => patternsValidationMessage, logMessage); } redirect = redirectService.GetPageRedirect(page.PageUrl); if (redirect != null) { redirect.RedirectUrl = model.RedirectUrl; } else { redirect = redirectService.CreateRedirectEntity(page.PageUrl, model.RedirectUrl); } if (redirect != null) { repository.Save(redirect); } } else { redirect = null; } // Delete child entities. if (page.PageTags != null) { foreach (var pageTag in page.PageTags) { repository.Delete(pageTag); } } var deletedPageContents = new List <PageContent>(); var htmlContentsToDelete = new List <HtmlContent>(); if (page.PageContents != null) { foreach (var pageContent in page.PageContents) { // If content is HTML content, delete HTML content var htmlContent = pageContent.Content as HtmlContent; if (htmlContent != null) { var draft = pageContent.Content.History != null?pageContent.Content.History.FirstOrDefault(c => c.Status == ContentStatus.Draft) : null; if (draft != null) { repository.Delete(draft); } repository.Delete(htmlContent); htmlContentsToDelete.Add(htmlContent); } repository.Delete(pageContent); deletedPageContents.Add(pageContent); } } if (page.Options != null) { foreach (var option in page.Options) { repository.Delete(option); } } if (page.AccessRules != null) { var rules = page.AccessRules.ToList(); rules.ForEach(page.RemoveRule); } if (page.MasterPages != null) { foreach (var master in page.MasterPages) { repository.Delete(master); } } // Delete page repository.Delete <Root.Models.Page>(page); // Commit unitOfWork.Commit(); var updatedSitemaps = new List <Sitemap>(); foreach (var node in updatedNodes) { Events.SitemapEvents.Instance.OnSitemapNodeUpdated(node); if (!updatedSitemaps.Contains(node.Sitemap)) { updatedSitemaps.Add(node.Sitemap); } } foreach (var node in deletedNodes) { Events.SitemapEvents.Instance.OnSitemapNodeDeleted(node); if (!updatedSitemaps.Contains(node.Sitemap)) { updatedSitemaps.Add(node.Sitemap); } } foreach (var updatedSitemap in updatedSitemaps) { Events.SitemapEvents.Instance.OnSitemapUpdated(updatedSitemap); } // Notifying about redirect created if (redirect != null) { Events.PageEvents.Instance.OnRedirectCreated(redirect); } // Notify about deleted page contents foreach (var deletedPageContent in deletedPageContents) { Events.PageEvents.Instance.OnPageContentDeleted(deletedPageContent); } // Notify about deleted html contents foreach (var htmlContent in htmlContentsToDelete) { Events.PageEvents.Instance.OnHtmlContentDeleted(htmlContent); } // Notifying, that page is deleted. Events.PageEvents.Instance.OnPageDeleted(page); if (sitemaps.Any(tuple => !tuple.Value) && messages != null) { // Some sitemaps where skipped, because user has no permission to edit. messages.AddSuccess(PagesGlobalization.DeletePage_SitemapSkipped_Message); } return(true); }
/// <summary> /// Saves the blog post. /// </summary> /// <param name="request">The request.</param> /// <param name="childContentOptionValues">The child content option values.</param> /// <param name="principal">The principal.</param> /// <param name="errorMessages">The error messages.</param> /// <param name="updateActivationIfNotChanged">if set to <c>true</c> update activation time even if it was not changed.</param> /// <returns> /// Saved blog post entity /// </returns> /// <exception cref="System.ComponentModel.DataAnnotations.ValidationException"></exception> /// <exception cref="SecurityException">Forbidden: Access is denied.</exception> public BlogPost SaveBlogPost(BlogPostViewModel request, IList <ContentOptionValuesViewModel> childContentOptionValues, IPrincipal principal, out string[] errorMessages, bool updateActivationIfNotChanged = true) { errorMessages = new string[0]; string[] roles; if (request.DesirableStatus == ContentStatus.Published) { accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.PublishContent); roles = new[] { RootModuleConstants.UserRoles.PublishContent }; } else { accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.EditContent); roles = new[] { RootModuleConstants.UserRoles.EditContent }; } var isNew = request.Id.HasDefaultValue(); var userCanEdit = securityService.IsAuthorized(RootModuleConstants.UserRoles.EditContent); ValidateData(isNew, request); BlogPost blogPost; BlogPostContent content; PageContent pageContent; GetBlogPostAndContentEntities(request, principal, roles, ref isNew, out content, out pageContent, out blogPost); var beforeChange = new UpdatingBlogModel(blogPost); // Master page / layout Layout layout; Page masterPage; Region region; LoadDefaultLayoutAndRegion(out layout, out masterPage, out region); if (masterPage != null) { var level = accessControlService.GetAccessLevel(masterPage, principal); if (level < AccessLevel.Read) { var message = BlogGlobalization.SaveBlogPost_FailedToSave_InaccessibleMasterPage; const string logMessage = "Failed to save blog post. Selected master page for page layout is inaccessible."; throw new ValidationException(() => message, logMessage); } } if (pageContent.Region == null) { pageContent.Region = region; } // Load master pages for updating page's master path and page's children master path IList <Guid> newMasterIds; IList <Guid> oldMasterIds; IList <Guid> childrenPageIds; IList <MasterPage> existingChildrenMasterPages; PrepareForUpdateChildrenMasterPages(isNew, blogPost, request, out newMasterIds, out oldMasterIds, out childrenPageIds, out existingChildrenMasterPages); // TODO: TEST AND TRY TO FIX IT: TRANSACTION HERE IS REQUIRED! // UnitOfWork.BeginTransaction(); // NOTE: this causes concurrent data exception. Redirect redirectCreated = null; if (!isNew && userCanEdit && !string.Equals(blogPost.PageUrl, request.BlogUrl) && !string.IsNullOrWhiteSpace(request.BlogUrl)) { request.BlogUrl = urlService.FixUrl(request.BlogUrl); pageService.ValidatePageUrl(request.BlogUrl, request.Id); if (request.RedirectFromOldUrl) { var redirect = redirectService.CreateRedirectEntity(blogPost.PageUrl, request.BlogUrl); if (redirect != null) { repository.Save(redirect); redirectCreated = redirect; } } blogPost.PageUrl = urlService.FixUrl(request.BlogUrl); } // Push to change modified data each time. blogPost.ModifiedOn = DateTime.Now; if (userCanEdit) { blogPost.Title = request.Title; blogPost.Description = request.IntroText; blogPost.Author = request.AuthorId.HasValue ? repository.AsProxy <Author>(request.AuthorId.Value) : null; categoryService.CombineEntityCategories <BlogPost, PageCategory>(blogPost, request.Categories); blogPost.Image = (request.Image != null && request.Image.ImageId.HasValue) ? repository.AsProxy <MediaImage>(request.Image.ImageId.Value) : null; if (isNew || request.DesirableStatus == ContentStatus.Published) { if (updateActivationIfNotChanged) { blogPost.ActivationDate = request.LiveFromDate; blogPost.ExpirationDate = TimeHelper.FormatEndDate(request.LiveToDate); } else { blogPost.ActivationDate = TimeHelper.GetFirstIfTheSameDay(blogPost.ActivationDate, request.LiveFromDate); blogPost.ExpirationDate = TimeHelper.GetFirstIfTheSameDay(blogPost.ExpirationDate, TimeHelper.FormatEndDate(request.LiveToDate)); } } } if (isNew) { if (!string.IsNullOrWhiteSpace(request.BlogUrl)) { blogPost.PageUrl = urlService.FixUrl(request.BlogUrl); pageService.ValidatePageUrl(blogPost.PageUrl); } else { blogPost.PageUrl = CreateBlogPermalink(request.Title, null, blogPost.Categories != null ? blogPost.Categories.Select(x => x.Id) : null); } blogPost.MetaTitle = request.MetaTitle ?? request.Title; if (masterPage != null) { blogPost.MasterPage = masterPage; masterPageService.SetPageMasterPages(blogPost, masterPage.Id); } else { blogPost.Layout = layout; } UpdateStatus(blogPost, request.DesirableStatus); AddDefaultAccessRules(blogPost, principal, masterPage); } else if (request.DesirableStatus == ContentStatus.Published || blogPost.Status == PageStatus.Preview) { // Update only if publishing or current status is preview. // Else do not change, because it may change from published to draft status UpdateStatus(blogPost, request.DesirableStatus); } // Create content. var newContent = new BlogPostContent { Id = content != null ? content.Id : Guid.Empty, Name = request.Title, Html = request.Content ?? string.Empty, EditInSourceMode = request.EditInSourceMode, ActivationDate = request.LiveFromDate, ExpirationDate = TimeHelper.FormatEndDate(request.LiveToDate) }; if (!updateActivationIfNotChanged && content != null) { newContent.ActivationDate = TimeHelper.GetFirstIfTheSameDay(content.ActivationDate, newContent.ActivationDate); newContent.ExpirationDate = TimeHelper.GetFirstIfTheSameDay(content.ExpirationDate, newContent.ExpirationDate); } // Preserve content if user is not authorized to change it. if (!userCanEdit) { if (content == null) { throw new SecurityException("Forbidden: Access is denied."); // User has no rights to create new content. } var contentToPublish = (BlogPostContent)(content.History != null ? content.History.FirstOrDefault(c => c.Status == ContentStatus.Draft) ?? content : content); newContent.Name = contentToPublish.Name; newContent.Html = contentToPublish.Html; } content = SaveContentWithStatusUpdate(isNew, newContent, request, principal); pageContent.Content = content; optionService.SaveChildContentOptions(content, childContentOptionValues, request.DesirableStatus); blogPost.PageUrlHash = blogPost.PageUrl.UrlHash(); blogPost.UseCanonicalUrl = request.UseCanonicalUrl; MapExtraProperties(isNew, blogPost, content, pageContent, request, principal); // Notify about page properties changing. var cancelEventArgs = Events.BlogEvents.Instance.OnBlogChanging(beforeChange, new UpdatingBlogModel(blogPost)); if (cancelEventArgs.Cancel) { errorMessages = cancelEventArgs.CancellationErrorMessages.ToArray(); return(null); } repository.Save(blogPost); repository.Save(content); repository.Save(pageContent); masterPageService.UpdateChildrenMasterPages(existingChildrenMasterPages, oldMasterIds, newMasterIds, childrenPageIds); pageContent.Content = content; blogPost.PageContents = new [] { pageContent }; IList <Tag> newTags = null; if (userCanEdit) { newTags = SaveTags(blogPost, request); } // Commit unitOfWork.Commit(); // Notify about new created tags. Events.RootEvents.Instance.OnTagCreated(newTags); // Notify about new or updated blog post. if (isNew) { Events.BlogEvents.Instance.OnBlogCreated(blogPost); } else { Events.BlogEvents.Instance.OnBlogUpdated(blogPost); } // Notify about redirect creation. if (redirectCreated != null) { Events.PageEvents.Instance.OnRedirectCreated(redirectCreated); } return(blogPost); }
public void Migrate() { try { var consumersFromSugar = _sugarDataContext.Query <WWhatsInTheBag>().OrderByDescending(x => x.DateModified).ToList(); var whatsInTheBagSugar = _sugarDataContext.Query <WWhatsInTheBagCstm>().ToList(); var whatsInToConsumerSugar = _sugarDataContext.Query <WWhatsInTheBagCConsumersC>(); var countFromSugar = consumersFromSugar.Count; var loopCount = countFromSugar / _splitCount; if (loopCount > 0) { loopCount = countFromSugar; } _logger.LogInformation("#################Starting Migration of Whats in the bag"); _logger.LogInformation($"Found {countFromSugar} to migrate"); for (var x = 0; x < loopCount; x++) { var skip = x * _splitCount; if (skip > countFromSugar) { break; } _logger.LogInformation($"Starting segment starting at {skip}"); _repository.ReloadContext(); _repository.GetDatabase().ChangeTracker.AutoDetectChangesEnabled = false; var sugarItems = consumersFromSugar.Skip(x * _splitCount).Take(_splitCount).ToList(); foreach (var sItem in sugarItems) { var bagItem = whatsInTheBagSugar.FirstOrDefault(y => y.IdC == sItem.Id); var itemToConsumer = whatsInToConsumerSugar.FirstOrDefault(y => y.WWhatsInTheBagCConsumerswWhatsInTheBagIdb == sItem.Id); var consumerOld = _sugarDataContext.Query <CConsumers>().FirstOrDefault(y => y.Id == itemToConsumer.WWhatsInTheBagCConsumerscConsumersIda); if (consumerOld == null) { continue; } var consumer = _repository.Query <ConsumerData.Models.Consumer>() .Include(y => y.GolferProfile) .FirstOrDefault(y => y.PrimaryEmail.ToLower() == consumerOld.Email.ToLower()); if (consumer == null) { continue; } if (consumer.GolferProfile == null) { consumer.GolferProfile = new ConsumerData.Models.GolferProfile { Created = DateTime.UtcNow, ConsumerId = consumer.Id.Value }; _repository.SaveQueue(consumer); } var cdmItem = new ConsumerData.Models.WhatsInTheBag { ClubShaftFlexId = _staticTableHelper.GetFlexId(bagItem.FlexC), ClubLoftId = _staticTableHelper.GetLoftId(bagItem.LoftC), FaceLieAdjustmentId = _staticTableHelper.GetLieId(bagItem.FaceLieAdjustmentC), FaceLoftAdjustmentId = _staticTableHelper.GetLoftId(bagItem.FaceLoftAdjustmentC), Created = DateTime.UtcNow, ClubCategoryId = _staticTableHelper.GetCategoryId(sItem.Category), BrandId = _staticTableHelper.GetBrandId(sItem.Vendor), ClubCategoryTypeId = _staticTableHelper.GetClubCategoryTypeId(bagItem.HeadLoftC), ModelId = _staticTableHelper.GetModelId(sItem.Model), PlanToPurchase = !string.IsNullOrWhiteSpace(sItem.PlanningToPurchase), ClubShaftLengthId = _staticTableHelper.GetChaftLengthId(bagItem.ShaftLengthC), Sku = bagItem.SkuC, GolferProfileId = consumer.GolferProfile.Id }; try { _repository.SaveQueue(cdmItem); } catch (Exception e) { _logger.LogError(e.Message); } } _logger.LogInformation($"Saving Whats in the bag " + DateTime.UtcNow.ToLongDateString()); try { _repository.Save(); } catch (Exception e) { _logger.LogError(e.Message); } _logger.LogInformation($"Saving Whats in the bag" + DateTime.UtcNow.ToLongDateString()); } } catch (Exception e) { _logger.LogError("Migrate [WhatsInTheBag] failed", e); } }
private List <BlogPostImportResult> ImportBlogPosts(IPrincipal principal, IDictionary <string, Guid> authors, IDictionary <string, Guid> categories, List <BlogMLPost> blogs, List <BlogPostImportResult> modifications, bool createRedirects = false) { var createdBlogPosts = new List <BlogPostImportResult>(); if (blogs != null) { foreach (var blogML in blogs) { BlogPostViewModel blogPostModel = null; try { blogPostModel = MapViewModel(blogML, modifications.First(m => m.Id == blogML.ID)); BlogPostImportResult blogPostResult = null; if (!ValidateModel(blogPostModel, blogML, out blogPostResult)) { createdBlogPosts.Add(blogPostResult); continue; } if (blogML.Authors != null && blogML.Authors.Count > 0) { blogPostModel.AuthorId = authors[blogML.Authors[0].Ref]; } if (blogML.Categories != null && blogML.Categories.Count > 0 && categories != null && categories.Count > 0) { for (var i = 0; i < blogML.Categories.Count; i++) { var category = blogML.Categories[i]; if (blogPostModel.Categories == null) { blogPostModel.Categories = new List <LookupKeyValue>(); } blogPostModel.Categories.Add(new LookupKeyValue() { Key = categories[category.Ref].ToLowerInvariantString() }); } } string[] error; var blogPost = blogService.SaveBlogPost(blogPostModel, null, principal, out error); if (blogPost == null) { blogPostResult = new BlogPostImportResult { Title = blogML.PostName ?? blogML.Title, Success = false, ErrorMessage = error.Length > 0 ? error[0] : string.Empty }; createdBlogPosts.Add(blogPostResult); continue; } blogPostResult = new BlogPostImportResult { Title = blogML.PostName ?? blogML.Title, PageUrl = blogPost.PageUrl, Id = blogPost.Id.ToString(), Success = true }; createdBlogPosts.Add(blogPostResult); if (createRedirects) { var oldUrl = TryValidateOldUrl(blogML.PostUrl); if (oldUrl != null && oldUrl != blogPostModel.BlogUrl) { var redirect = redirectService.GetPageRedirect(oldUrl); if (redirect == null) { redirect = redirectService.CreateRedirectEntity(oldUrl, blogPostModel.BlogUrl); repository.Save(redirect); unitOfWork.Commit(); Events.PageEvents.Instance.OnRedirectCreated(redirect); } else { blogPostResult.WarnMessage = string.Format(BlogGlobalization.ImportBlogPosts_RedirectWasAlreadyCreatedFor_Message, blogML.PostUrl); } } else if (oldUrl == null) { blogPostResult.WarnMessage = string.Format(BlogGlobalization.ImportBlogPosts_FailedToCreateRedirectFor_Message, blogML.PostUrl); } } } catch (Exception exc) { var failedBlogPost = new BlogPostImportResult { Title = blogML.PostName ?? blogML.Title, PageUrl = blogPostModel != null && blogPostModel.BlogUrl != null ? blogPostModel.BlogUrl : blogML.PostUrl, Success = false, ErrorMessage = exc.Message, Id = blogML.ID }; createdBlogPosts.Add(failedBlogPost); Log.Error("Failed to import blog post.", exc); } } } return(createdBlogPosts); }
private void SaveToDb(User user) { _userRepository.Save(user); _userRepository.Commit(); }
public override void HandleMessage(Yupi.Model.Domain.Habbo session, Yupi.Protocol.Buffers.ClientMessage message, Yupi.Protocol.IRouter router) { session.Info.Preferences.PreferOldChat = message.GetBool(); UserRepository.Save(session.Info); }
public void UpdateSensor(SensorsFromUser editedSensor) { sensorRepo.Update(editedSensor); sensorRepo.Save(); }
/// <summary> /// Puts the specified request. /// </summary> /// <param name="request">The request.</param> /// <returns><c>PutPageResponse</c> with created or updated item id.</returns> public PutPagePropertiesResponse Put(PutPagePropertiesRequest request) { if (request.Data.IsMasterPage) { accessControlService.DemandAccess(securityService.GetCurrentPrincipal(), RootModuleConstants.UserRoles.Administration); } else { accessControlService.DemandAccess(securityService.GetCurrentPrincipal(), RootModuleConstants.UserRoles.EditContent); } PageProperties pageProperties = null; var isNew = !request.Id.HasValue || request.Id.Value.HasDefaultValue(); if (!isNew) { pageProperties = repository.AsQueryable <PageProperties>(e => e.Id == request.Id.GetValueOrDefault()) .FetchMany(p => p.Options) .Fetch(p => p.Layout) .ThenFetchMany(l => l.LayoutOptions) .FetchMany(p => p.MasterPages) .FetchMany(f => f.AccessRules) .ToList() .FirstOrDefault(); isNew = pageProperties == null; } UpdatingPagePropertiesModel beforeChange = null; if (isNew) { pageProperties = new PageProperties { Id = request.Id.GetValueOrDefault(), Status = PageStatus.Unpublished, AccessRules = new List <AccessRule>() }; } else if (request.Data.Version > 0) { pageProperties.Version = request.Data.Version; } if (!isNew) { beforeChange = new UpdatingPagePropertiesModel(pageProperties); } if (!isNew && pageProperties.IsMasterPage != request.Data.IsMasterPage) { const string message = "IsMasterPage cannot be changed for updating page. It can be modified only when creating a page."; var logMessage = string.Format("{0} PageId: {1}", message, request.Id); throw new ValidationException(() => message, logMessage); } // Load master pages for updating page's master path and page's children master path IList <Guid> newMasterIds; IList <Guid> oldMasterIds; IList <Guid> childrenPageIds; IList <MasterPage> existingChildrenMasterPages; masterPageService.PrepareForUpdateChildrenMasterPages(pageProperties, request.Data.MasterPageId, out newMasterIds, out oldMasterIds, out childrenPageIds, out existingChildrenMasterPages); unitOfWork.BeginTransaction(); if (!string.IsNullOrEmpty(request.Data.PageUrl) || string.IsNullOrEmpty(pageProperties.PageUrl)) { var pageUrl = request.Data.PageUrl; if (string.IsNullOrEmpty(pageUrl) && !string.IsNullOrWhiteSpace(request.Data.Title)) { pageUrl = pageService.CreatePagePermalink(request.Data.Title, null, null, request.Data.LanguageId, request.Data.Categories); } else { pageUrl = urlService.FixUrl(pageUrl); pageService.ValidatePageUrl(pageUrl, request.Id); } pageProperties.PageUrl = pageUrl; pageProperties.PageUrlHash = pageUrl.UrlHash(); } pageProperties.Title = request.Data.Title; pageProperties.Description = request.Data.Description; var newStatus = request.Data.IsMasterPage || request.Data.IsPublished ? PageStatus.Published : PageStatus.Unpublished; if (!request.Data.IsMasterPage && pageProperties.Status != newStatus) { accessControlService.DemandAccess(securityService.GetCurrentPrincipal(), RootModuleConstants.UserRoles.PublishContent); } pageProperties.Status = newStatus; pageProperties.PublishedOn = request.Data.IsPublished && !request.Data.PublishedOn.HasValue ? DateTime.Now : request.Data.PublishedOn; masterPageService.SetMasterOrLayout(pageProperties, request.Data.MasterPageId, request.Data.LayoutId); categoryService.CombineEntityCategories <PageProperties, PageCategory>(pageProperties, request.Data.Categories); pageProperties.IsArchived = request.Data.IsArchived; pageProperties.IsMasterPage = request.Data.IsMasterPage; pageProperties.LanguageGroupIdentifier = request.Data.LanguageGroupIdentifier; pageProperties.ForceAccessProtocol = (Core.DataContracts.Enums.ForceProtocolType)(int) request.Data.ForceAccessProtocol; pageProperties.Language = request.Data.LanguageId.HasValue && !request.Data.LanguageId.Value.HasDefaultValue() ? repository.AsProxy <Language>(request.Data.LanguageId.Value) : null; pageProperties.Image = request.Data.MainImageId.HasValue ? repository.AsProxy <MediaImage>(request.Data.MainImageId.Value) : null; pageProperties.FeaturedImage = request.Data.FeaturedImageId.HasValue ? repository.AsProxy <MediaImage>(request.Data.FeaturedImageId.Value) : null; pageProperties.SecondaryImage = request.Data.SecondaryImageId.HasValue ? repository.AsProxy <MediaImage>(request.Data.SecondaryImageId.Value) : null; pageProperties.CustomCss = request.Data.CustomCss; pageProperties.CustomJS = request.Data.CustomJavaScript; pageProperties.UseCanonicalUrl = request.Data.UseCanonicalUrl; pageProperties.UseNoFollow = request.Data.UseNoFollow; pageProperties.UseNoIndex = request.Data.UseNoIndex; if (request.Data.MetaData != null) { pageProperties.MetaTitle = request.Data.MetaData.MetaTitle; pageProperties.MetaDescription = request.Data.MetaData.MetaDescription; pageProperties.MetaKeywords = request.Data.MetaData.MetaKeywords; } IList <Tag> newTags = null; if (request.Data.Tags != null) { tagService.SavePageTags(pageProperties, request.Data.Tags, out newTags); } if (request.Data.AccessRules != null) { pageProperties.AccessRules.RemoveDuplicateEntities(); var accessRules = request.Data.AccessRules.Select( r => (IAccessRule) new AccessRule { AccessLevel = (Core.Security.AccessLevel)(int) r.AccessLevel, Identity = r.Identity, IsForRole = r.IsForRole }) .ToList(); accessControlService.UpdateAccessControl(pageProperties, accessRules); } if (request.Data.PageOptions != null) { var options = request.Data.PageOptions.ToServiceModel(); var pageOptions = pageProperties.Options != null?pageProperties.Options.Distinct() : null; pageProperties.Options = optionService.SaveOptionValues(options, pageOptions, () => new PageOption { Page = pageProperties }); } if (!isNew) { // Notify about page properties changing. var cancelEventArgs = Events.PageEvents.Instance.OnPagePropertiesChanging(beforeChange, new UpdatingPagePropertiesModel(pageProperties)); if (cancelEventArgs.Cancel) { throw new CmsApiValidationException( cancelEventArgs.CancellationErrorMessages != null && cancelEventArgs.CancellationErrorMessages.Count > 0 ? string.Join(",", cancelEventArgs.CancellationErrorMessages) : "Page properties saving was canceled."); } } repository.Save(pageProperties); // // If creating new page, page id is unknown when children pages are loaded, so Guid may be empty // Updating id to saved page's Id manually // if (isNew && childrenPageIds != null && childrenPageIds.Count == 1 && childrenPageIds[0].HasDefaultValue()) { childrenPageIds[0] = pageProperties.Id; } masterPageService.UpdateChildrenMasterPages(existingChildrenMasterPages, oldMasterIds, newMasterIds, childrenPageIds); unitOfWork.Commit(); // Fire events. Events.RootEvents.Instance.OnTagCreated(newTags); if (isNew) { Events.PageEvents.Instance.OnPageCreated(pageProperties); } else { Events.PageEvents.Instance.OnPagePropertiesChanged(pageProperties); } return(new PutPagePropertiesResponse { Data = pageProperties.Id }); }
public void AltaHistorialCompraVentaLibro(HistorialCompraVentaLibro historialCompraVentaLibro) { _historialCompraVentaLibroRepository.Save(historialCompraVentaLibro); }
public bool Save() { return(_db.Save()); }
private void Save() { db.Save(); }
public void Post([FromBody] Client client) { repository.Create(client); repository.Save(); }
public void Create(EWeeklyReportDto eWeeklyReporttDto) { _repositoryEWeeklyReport.Create(Mapper.Map <EWeeklyReport>(eWeeklyReporttDto)); _repositoryEWeeklyReport.Save(); }
public void Handle(CreateToDoListCommand command) { ToDoList todoList = new ToDoList(command.Id, command.Title, command.Description); _repo.Save(todoList, Guid.NewGuid()); }
/// <summary> /// Saves changes for this table /// and re caches the table data. /// </summary> public async Task Save() { await _repository.Save(); await CacheTable(); }
public IActionResult Post(TodoItem item) { return(Ok(_repository.Save(item))); }
public Task Save <T>(T aggregate, int?expectedVersion = null, CancellationToken cancellationToken = default(CancellationToken)) where T : AggregateRoot { return(Task.WhenAll(TryMakeSnapshot(aggregate), _repository.Save(aggregate, expectedVersion, cancellationToken))); }
/// <summary> /// Uploads the image. /// </summary> /// <param name="rootFolderId">The root folder id.</param> /// <param name="fileName">Name of the file.</param> /// <param name="fileLength">Length of the file.</param> /// <param name="fileStream">The file stream.</param> /// <param name="reuploadMediaId">The reupload media identifier.</param> /// <param name="overrideUrl">if set to <c>true</c> override URL.</param> /// <returns> /// Image entity. /// </returns> public MediaImage UploadImage(Guid rootFolderId, string fileName, long fileLength, Stream fileStream, Guid reuploadMediaId, bool overrideUrl = true) { overrideUrl = false; // TODO: temporary disabling feature #1055. var folderName = mediaFileService.CreateRandomFolderName(); var publicFileName = MediaHelper.RemoveInvalidPathSymbols(MediaImageHelper.CreatePublicFileName(fileName, Path.GetExtension(fileName))); var fileExtension = Path.GetExtension(fileName); var imageType = ImageHelper.GetImageType(fileExtension); MediaImage uploadImage = null; MemoryStream thumbnailFileStream = new MemoryStream(); Size size; Size thumbnailSize = ThumbnailSize; long thumbnailImageLength; /* Upload standard raster type images */ if (imageType == ImageType.Raster) { fileStream = RotateImage(fileStream); size = GetSize(fileStream); CreatePngThumbnail(fileStream, thumbnailFileStream, ThumbnailSize); thumbnailImageLength = thumbnailFileStream.Length; } /* Upload vector graphics images */ else { size = Size.Empty; ReadParametersFormVectorImage(fileStream, ref size); thumbnailImageLength = fileStream.Length; CreateSvgThumbnail(fileStream, thumbnailFileStream, ThumbnailSize); } try { if (!reuploadMediaId.HasDefaultValue()) { // Re-uploading image: Get original image, folder name, file extension, file name uploadImage = (MediaImage)repository.First <MediaImage>(image => image.Id == reuploadMediaId).Clone(); uploadImage.IsTemporary = true; // Create new original image and upload file stream to the storage uploadImage = CreateImage(rootFolderId, fileName, fileExtension, Path.GetFileName(fileName), size, fileLength); } else { // Uploading new image // Create new original image and upload file stream to the storage uploadImage = CreateImage( rootFolderId, fileName, fileExtension, Path.GetFileName(fileName), size, fileLength); } SetThumbnailParameters(uploadImage, thumbnailSize, thumbnailImageLength); mediaImageVersionPathService.SetPathForNewOriginal(uploadImage, folderName, publicFileName, imageType); unitOfWork.BeginTransaction(); repository.Save(uploadImage); unitOfWork.Commit(); StartTasksForImage(uploadImage, fileStream, thumbnailFileStream, false); } finally { if (thumbnailFileStream != null) { thumbnailFileStream.Dispose(); } } return(uploadImage); }
public void AddMessage(Message message) { _messageRepository.Add(message); _messageRepository.Save(); }
public bool Save() { return(_repository.Save()); }
public void Handle(AddNewToDoItemCommand command) { ToDoItem item = new ToDoItem(command.TodoListId, command.Id, command.CreationDate, command.Description, command.DueDate, command.Importance); _repo.Save(item, Guid.NewGuid()); }
public void Save(TeamMember member) { _repository.Save(member); }
public void SaveBook(Book book) { _repository.Save(book); }
public void Save() { employeeRepository.Save(); }
public Team AddTeam(Team newTeam) { newTeam.ID = GetNewId(); return(repository.Save(newTeam)); }
public void RemoveVendedor(Vendedor vendedor) { vendedorRP.Delete(vendedor); vendedorRP.Save(); }
public EmployeeServiceTest() { _employeeRepository = new MemoryRepository <Employee>(); _allEmployees = SetupEmployees(); _allEmployees.ForEach(empl => _employeeRepository.Save(empl.Id, empl)); }
public virtual void Save() { BaseRepository.Save(); }
private PageProperties ClonePage(System.Guid pageId, string pageTitle, string pageUrl, IEnumerable <IAccessRule> userAccessList, bool cloneAsMasterPage, System.Guid?languageId, System.Guid?languageGroupIdentifier) { var principal = securityService.GetCurrentPrincipal(); if (cloneAsMasterPage) { accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.Administration); } else { accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.EditContent); } // Create / fix page url if (pageUrl == null && !string.IsNullOrWhiteSpace(pageTitle)) { pageUrl = pageService.CreatePagePermalink(pageTitle, null); } else { pageUrl = urlService.FixUrl(pageUrl); pageService.ValidatePageUrl(pageUrl); } var page = repository .AsQueryable <PageProperties>() .Where(f => f.Id == pageId) .FetchMany(f => f.Options) .FetchMany(f => f.PageContents).ThenFetch(f => f.Region) .FetchMany(f => f.PageContents).ThenFetch(f => f.Content) .FetchMany(f => f.PageContents).ThenFetchMany(f => f.Options) .FetchMany(f => f.PageTags).ThenFetch(f => f.Tag) .FetchMany(f => f.MasterPages).ThenFetch(f => f.Master) .ToList().FirstOne(); ValidateCloningPage(page, languageId, languageGroupIdentifier); unitOfWork.BeginTransaction(); // Detach page to avoid duplicate saving. repository.Detach(page); page.PageContents.ForEach(repository.Detach); page.PageTags.ForEach(repository.Detach); page.Options.ForEach(repository.Detach); page.SaveUnsecured = true; var pageContents = page.PageContents.Distinct().ToList(); var pageTags = page.PageTags.Distinct().ToList(); var pageOptions = page.Options.Distinct().ToList(); var masterPages = page.MasterPages != null?page.MasterPages.Distinct().ToList() : new List <MasterPage>(); // Clone page with security var newPage = ClonePageOnly(page, userAccessList, pageTitle, pageUrl, cloneAsMasterPage); if (languageId.HasValue) { if (languageId.Value.HasDefaultValue()) { newPage.Language = null; } else { newPage.Language = repository.AsProxy <Language>(languageId.Value); } } if (languageGroupIdentifier.HasValue) { newPage.LanguageGroupIdentifier = languageGroupIdentifier.Value; } else { newPage.LanguageGroupIdentifier = null; } repository.Save(newPage); // Clone contents. pageContents.ForEach(pageContent => ClonePageContent(pageContent, newPage)); // Clone tags. pageTags.ForEach(pageTag => ClonePageTags(pageTag, newPage)); // Clone options. pageOptions.ForEach(pageOption => ClonePageOption(pageOption, newPage)); // Clone master pages masterPages.ForEach(masterPage => CloneMasterPages(masterPage, newPage)); // Set language identifier for parent page, if it hasn't and child is cloned from the parent. if (languageGroupIdentifier.HasValue && !page.LanguageGroupIdentifier.HasValue) { page.LanguageGroupIdentifier = languageGroupIdentifier.Value; repository.Save(page); } unitOfWork.Commit(); Events.PageEvents.Instance.OnPageCloned(newPage); return(newPage); }
public void TestInit() { repository = new DefaultRepository(fileStoreService, cacheStoreService); repository.Save(RepositoryTests.GetContentTypeCollection()); }
public Customer SaveCustomer(Customer customer) { return(_repository.Save(customer)); }