public async Task CreateAsync(Client client) { Ensure.That(client.Id == null, "Client Id is set internally when creating new clients"); Ensure.NotNullOrEmpty(client.TenantKey); client.Id = KeyGen.NewGuid(); // Initialize OIDC for this new client var tenant = await _tenantManager.CreateAsync(client.TenantKey, client.Name); var directory = await _directoryManager.CreateAsync(client.TenantKey, "Default User Directory"); // create a new security pool mapped to the default directory var clientSecurityPool = await _poolManager.CreateTenantPoolAsync ( client.TenantKey, client.Name + " Pool", new Identity.Models.Directory[] { directory } ); // Create the Connect Client client.SecurityPoolId = clientSecurityPool.PoolId; if (client.AnniversaryDate == null) { client.AnniversaryDate = DateTime.UtcNow; } _db.Add(client); await _db.SaveChangesAsync(); // Insert default roles await CreateDefaultClientLevelRoles(client); }
//agregar public async Task <Pais> Add(Pais pais) { var newPais = await _context.Paises.AddAsync(pais); await _context.SaveChangesAsync(); return(newPais.Entity); }
public async Task <Province> Add(Province province) { var newProvince = await _context.Provinces.AddAsync(province); await _context.SaveChangesAsync(); return(newProvince.Entity); }
public async Task <MigrationResult> ExecuteAsync() { var output = new System.Text.StringBuilder(); // Fail if cannot connect to db if (_connectDb.Database.TryTestConnection() == false) { return(MigrationResult.Failed("Cannot connect to database.")); } // Check if internal product already exists var exists = await _connectDb.Products.AnyAsync(x => x.Id == DbKeys.ProductIds.Internal); if (exists) { // early terminate return(MigrationResult.Skipped("Product already exists")); } // Register the product var internalProduct = new Product { Id = DbKeys.ProductIds.Internal, CategoryId = DbKeys.ProductCategoryIds.Angelo, Name = "Internal Corp Product", Description = "Internal product used for building PC|Mac demo sites.", SchemaFile = "/schemas/products/Product-0-Internal.json", Active = true }; _connectDb.Products.Add(internalProduct); await _connectDb.SaveChangesAsync(); // Update the PcMac Product Mapping var productMapping = await _connectDb.ClientProductApps .Include(x => x.AddOns) .FirstOrDefaultAsync( x => x.Id == DbKeys.ClientProductAppIds.PcMacApp1 ); productMapping.ProductId = DbKeys.ProductIds.Internal; productMapping.Title = internalProduct.Name; productMapping.MaxSiteCount = 500; // was previously 5 // Remove any previously seeded add-ons (the new product doesn't support any) if (productMapping.AddOns != null) { (productMapping.AddOns as List <ClientProductAddOn>).RemoveAll(x => true); } // Done await _connectDb.SaveChangesAsync(); return(MigrationResult.Success("Created product and mapped to PcMac client.")); }
//======================================================== CREATE ============================================== #region public async Task <T> CreateNTU(T entity) { try { await _db.Set <T>().AddAsync(entity); await _db.SaveChangesAsync(); return(await Task.FromResult(entity)); } catch (Exception e) { return(await Task.FromResult <T>(null)); } }
public static async Task <T> updateModel(ConnectDbContext _context, T model) { _context.Entry(model).State = EntityState.Modified; await _context.SaveChangesAsync(); return(model); }
public async Task <SiteAlert> SaveAsync(SiteAlert siteAlert) { siteAlert.Posted = DateTime.Now; var model = _db.SiteAlerts.FirstOrDefault(x => x.Id == siteAlert.Id); if (model != null) { model.Title = siteAlert.Title; model.Posted = siteAlert.Posted; model.Status = siteAlert.Status; model.StartDate = siteAlert.StartDate; model.EndDate = siteAlert.EndDate; model.VersionCode = siteAlert.VersionCode; model.ContentTreeId = siteAlert.ContentTreeId; _db.SiteAlerts.Update(model); } else { //_db.Entry(siteAlert).State = EntityState.Added; _db.SiteAlerts.Add(siteAlert); } await _db.SaveChangesAsync(); return(siteAlert); }
public async Task <MigrationResult> ExecuteAsync() { var announcementContentType = AnnouncementManager.CONTENT_TYPE_ANNOUNCEMENTPOST; // Fail if cannot connect to db if (_announcementDbContext.Database.TryTestConnection() == false || _connectDbContext.Database.TryTestConnection() == false) { return(MigrationResult.Failed("Cannot connect to database.")); } // remove any versioning records that are in an invalid state await _connectDbContext.Database.ExecuteNonQueryAsync($@" DELETE FROM cms.ContentVersion WHERE ContentType = '{announcementContentType}' AND JsonData IS NULL "); // Ensure UserId is set for remaining versions // NOTE: Will only affect QA / Dev environments where UserIds weren't being saved during early test versions await _announcementDbContext.Database.ExecuteNonQueryAsync(@" UPDATE cms.ContentVersion SET UserId = bp.UserId FROM plugin.AnnouncementPost bp WHERE cms.ContentVersion.ContentId = bp.Id AND cms.ContentVersion.UserId IS NULL "); // Identify announcements with valid version data to skip in next step // NOTE: These won't exist on production but might exist in dev / test environments var announcementIdsToSkip = await _connectDbContext.ContentVersions .Where(x => x.ContentType == announcementContentType && x.JsonData != null ) .Select(x => x.ContentId).ToArrayAsync(); // Identify announcement posts that have missing version data var announcementPostsToMigrate = await _announcementDbContext.AnnouncementPosts .Where(x => !announcementIdsToSkip.Contains(x.Id)) .ToListAsync(); // Insert the missing verision data foreach (var announcementPost in announcementPostsToMigrate) { var version = new ContentVersion(announcementContentType, announcementPost.Id); version.VersionCode = announcementPost.VersionCode; version.Created = announcementPost.Posted; version.Status = announcementPost.Published ? ContentStatus.Published : ContentStatus.Draft; version.UserId = announcementPost.UserId; version.JsonData = SerializeVersionData(announcementPost); _connectDbContext.ContentVersions.Add(version); } await _connectDbContext.SaveChangesAsync(); return(MigrationResult.Success($"Inserted {announcementPostsToMigrate.Count} missing AnnouncementPost version records")); }
public async Task <bool> UpdateFolderAsync(Folder folder) { var folder1 = await _db.Folders.Where(x => x.Id == folder.Id).FirstOrDefaultAsync(); if (folder1 == null) { return(false); } else { folder1.Title = folder.Title; folder1.DocumentType = folder.DocumentType; await _db.SaveChangesAsync(); return(true); } }
public async Task <string> CreateSiteCollectionAsync(SiteCollection siteCollection) { Ensure.That(siteCollection != null); try { siteCollection.Id = KeyGen.NewGuid(); _db.SiteCollections.Add(siteCollection); await _db.SaveChangesAsync(); return(siteCollection.Id); } catch (Exception) { return(null); } }
public async Task UnscheduleNotificationAsync(string Id) { var note = await _connectDb.Notifications.Where(x => x.Id == Id).FirstOrDefaultAsync(); if (note == null) { throw new Exception("Unable to unschedule notification (notification not found [" + Id + "])"); } if ((note.Status == NotificationStatus.Scheduled)) { note.Status = NotificationStatus.Draft; await _connectDb.SaveChangesAsync(); } else if (note.Status != NotificationStatus.Draft) { throw new Exception("Unable to unschedule notification (Id:" + Id + ", Status:" + note.Status + ")"); } }
public async Task <string> CreateCategoryAsync(Category category) { Ensure.That(category != null); try { category.Id = KeyGen.NewGuid(); _db.Categories.Add(category); await _db.SaveChangesAsync(); return(category.Id); } catch (Exception) { return(null); } }
public async Task <ResourceClaim> AddResourceClaimAsync(string resourceId, string resourceType, string userId, string claimType) { if (_db.ResourceClaims.Any(x => x.ResourceId == resourceId && x.ResourceType == resourceType && x.UserId == userId && x.ClaimType == claimType)) { return(null); } var resourceClaim = new ResourceClaim { ResourceId = resourceId, ResourceType = resourceType, UserId = userId, ClaimType = claimType }; _db.ResourceClaims.Add(resourceClaim); await _db.SaveChangesAsync(); return(resourceClaim); }
public async Task <string> CreateAsync(PageMaster pageMaster) { Ensure.Argument.NotNull(pageMaster); try { if (string.IsNullOrEmpty(pageMaster.Id)) { pageMaster.Id = KeyGen.NewGuid(); } _db.PageMasters.Add(pageMaster); await _db.SaveChangesAsync(); return(pageMaster.Id); } catch (Exception) { return(null); } }
//public async Task<List<UserGroupMembership>> GetUserGroupMembershipsAsync(string userGroupId) //{ // var query = _connectDb.UserGroupMemberships.AsNoTracking(); // //.Join(_db.NotificationUserGroups.Where(x => x.NotificationId == notificationId), // // ug => ug.Id, // // ng => ng.UserGroupId, // // (ug, ng) => ug); // var results = await query.ToListAsync(); // return results; //} public async Task UpdateUserGroupAsync(UserGroup userGroup) { var oldGroup = await _connectDb.UserGroups.Where(x => x.Id == userGroup.Id).FirstOrDefaultAsync(); if (oldGroup == null) { throw new Exception("Unable to find UserGroup (Id = " + userGroup.Id + ")"); } oldGroup.Name = userGroup.Name; oldGroup.AllowPublicEnrollment = userGroup.AllowPublicEnrollment; await _connectDb.SaveChangesAsync(); }
public virtual async Task DeleteAsync(string documentId) { var documentItems = _readDb .FolderItems .Where(x => x.DocumentId == documentId).ToList(); if (documentItems != null) { _readDb.FolderItems.RemoveRange(documentItems); await _readDb.SaveChangesAsync(); } var document = _readDb .FileDocuments .FirstOrDefault(x => x.DocumentId == documentId); if (document != null) { _readDb.FileDocuments.Remove(document); await _readDb.SaveChangesAsync(); } //TODO Send request to Drive to remove physical file }
private async Task <bool> UpdateFlagOnExistingSites() { var homePages = _connectDb.Pages.Where(x => x.Path == "/").ToList(); if (homePages.Any()) { foreach (var page in homePages) { page.IsHomePage = true; _connectDb.Pages.Update(page); } await _connectDb.SaveChangesAsync(); } return(await Task.FromResult(true)); }
public async Task <Tag> AddTag(string userId, string tagName) { var existingTag = await _db.Tags.FirstOrDefaultAsync(x => x.UserId == userId && x.TagName == tagName); if (existingTag != null) { return(existingTag); } var newTag = new Tag { Id = Guid.NewGuid().ToString("N"), TagName = tagName, UserId = userId, IsActive = true, }; _db.Tags.Add(newTag); await _db.SaveChangesAsync(); return(newTag); }
public async Task <bool> UpdateAsync(Page page) { Ensure.Argument.NotNull(page); var tempPage = _db.Pages.FirstOrDefault(x => x.Id == page.Id); if (tempPage == null) { return(false); } tempPage.Title = page.Title; tempPage.Keywords = page.Keywords; tempPage.Summary = page.Summary; tempPage.Path = CleanRoute(page.Path); tempPage.PageMasterId = page.PageMasterId; tempPage.IsPrivate = page.IsPrivate; tempPage.ParentPageId = page.ParentPageId; // Trimming strings if (!string.IsNullOrEmpty(tempPage.Title)) { tempPage.Title = tempPage.Title.Trim(); } if (!string.IsNullOrEmpty(tempPage.Keywords)) { tempPage.Keywords = tempPage.Keywords.Trim(); } if (!string.IsNullOrEmpty(tempPage.Summary)) { tempPage.Summary = tempPage.Summary.Trim(); } try { await _db.SaveChangesAsync(); return(true); } catch (Exception) { return(false); } }
public async Task AddFolderTagAsync(IFolder folder, string tag) { var exists = await HasTagAsync(folder, tag); // TODO: Consider throwing an error vs. not adding if (!exists) { var entity = BuildFolderTag(folder, tag); _db.FolderTags.Add(entity); await _db.SaveChangesAsync(); } }
public async Task DeleteNavMenuAsync(string navMenuId) { Ensure.Argument.NotNull(navMenuId); var menu = await _db.NavigationMenu.FirstOrDefaultAsync(x => x.Id == navMenuId); if (menu != null) { var items = await _db.NavigationMenuItems.Where(x => x.NavMenuId == navMenuId).ToListAsync(); foreach (var item in items) { _db.NavigationMenuItems.Remove(item); } _db.NavigationMenu.Remove(menu); await _db.SaveChangesAsync(); } }
/// =============================================== Create ====================================== /// <summary> /// Create entity. /// Before creating a new entity that is required to check if an entity already exists (email, phone, code, ...). /// If Checkvalue is false will insert success /// </summary> /// <param name="entity"></param> /// <param name="Checkvalue"></param> /// <returns>Entity</returns> #region public async Task <T> Create(T entity, bool CheckIsExist) { try { if (CheckIsExist) { return(await Task.FromResult <T>(null)); } await _db.Set <T>().AddAsync(entity); await _db.SaveChangesAsync(); return(await Task.FromResult(entity)); } catch (Exception e) { var error = e.Message; return(await Task.FromResult <T>(null)); } }
public async Task <int> SaveChangesAsync(CancellationToken cancellationToken) { return(await _context.SaveChangesAsync(cancellationToken)); }
public async Task RemoveSiteCollectionsAsync(string siteId, IList <string> siteCollectionIds) { var siteCollections = await _db.SiteCollectionMaps .Where(x => x.SiteId == siteId) .Where(x => siteCollectionIds.Contains(x.SiteCollectionId)) .ToListAsync(); _db.SiteCollectionMaps.RemoveRange(siteCollections); await _db.SaveChangesAsync(); }
public async Task UpdateVersionLabel(string contentType, string contentId, string versionCode, string versionLabel) { var version = await GetVersionInfo(contentType, contentId, versionCode); if (version == null) { throw new NullReferenceException("Cannot update version label. Version does not exist."); } if (string.IsNullOrEmpty(versionLabel)) { versionLabel = "Unlabeled Version"; } version.VersionLabel = versionLabel; await _connectDb.SaveChangesAsync(); }