public void Delete(int id) { lock (_session) { _session.Delete <Demographic>(id); } }
public void Delete(int id) { lock (_session) { _session.Delete <ClashException>(id); } }
private void DeleteSalesArea(Guid salesAreaId) { var salesArea = _session.Load <SalesArea>(salesAreaId); _session.Delete(salesArea); _session.SaveChanges(); }
public void DeleteRangeByExternalRefs(IEnumerable <string> externalRefs) { var products = _session.GetAll <Product>(s => s.Externalidentifier.In(externalRefs.ToList())); foreach (var product in products) { _session.Delete(product); } }
public void Delete(int id) { lock (_session) { var item = Get(id); if (item != null) { _session.Delete(item); } } }
public void Delete(Guid uid) { var item = Get(uid); if (item is null) { return; } _session.Delete(item); }
public void DeleteRange(IEnumerable <Guid> ids) { lock (_session) { var programmes = _session.GetAll <Programme>(s => s.Id.In(ids)); foreach (var programme in programmes) { _session.Delete(programme); } } }
// SAMPLE: deletes public void delete_documents(IDocumentSession session) { var user = new User(); session.Delete(user); session.SaveChanges(); // OR session.Delete(user.Id); session.SaveChanges(); }
public void DeleteBySalesAreaName(string name) { lock (_session) { var salesAreaDemographics = _session.GetAll <SalesAreaDemographic>(x => x.SalesArea == name); foreach (var salesAreaDemographic in salesAreaDemographics) { _session.Delete <SalesAreaDemographic>(salesAreaDemographic.Id); } } }
public void Remove(Guid uid) { lock (_session) { Spot spotToDelete = Find(uid); if (spotToDelete is null) { return; } _session.Delete(spotToDelete); } }
public void Delete(int id) { lock (_session) { var item = Get(id); if (item is null) { return; } _session.Delete(item); } }
public void Delete(int id) { lock (_session) { var positionGroup = Get(id); if (positionGroup is null) { return; } _session.Delete(positionGroup); } }
public override void RemoveFromSet(string key, string value) { var id = Repository.GetId(typeof(RavenSet), key); var set = _session.Load <RavenSet>(id); set.Scores.Remove(value); if (set.Scores.Count == 0) { _session.Delete(set); } }
public void Delete(Guid id) { lock (_session) { var scenario = Get(id); if (scenario is null) { return; } _session.Delete(scenario); } }
public override void RemoveFromSet(string key, string value) { key.ThrowIfNull(nameof(key)); var id = _storage.Repository.GetId(typeof(RavenSet), key); var set = FindOrCreateSet(id); set.Scores.Remove(value); if (set.Scores.Count == 0) { _session.Delete(set); } }
public async Task Delete(TodoAggregate item) { var _item = m_mapper.Map <Documents.TodoDocument>(item); m_session.Delete(_item); await m_session.SaveChangesAsync(); }
/// <summary> /// Remove a role /// </summary> /// <param name="applicationName">Application that the request is for.</param> /// <param name="roleName">Role to remove</param> public void RemoveRole(string applicationName, string roleName) { var role = _session.Query <Role>().Where(r => r.Name == roleName); _session.Delete(role); _session.SaveChanges(); }
/// <summary> /// Deletes a bunch of elements in a single call. /// </summary> /// <typeparam name="DBType">Type of the element stored in the database. This is used to identify the collection</typeparam> /// <param name="ids">Array containing the identifiers of the elements that have to be deleted</param> /// <returns>RepositoryResponse.RepositoryDelete if all the elements have been successfully deleted, /// RepositoryResponse.RepositoryGenericError otherwise</returns> public override RepositoryResponse BulkDelete <DBType>(string[] ids) { lock (_store) { using (IDocumentSession _session = _store.OpenSession()) { DBType[] ents = _session.Load <DBType>(ids); /*try * {*/ using (TransactionScope tx = new TransactionScope()) { foreach (DBType entity in ents) { _session.Delete <DBType>(entity); } _session.SaveChanges(); tx.Complete(); } return(RepositoryResponse.RepositoryDelete); /*} * catch (TransactionAbortedException tae) * { * log.Error("Transaction Aborted", tae); * return RepositoryResponse.RepositoryGenericError; * }*/ } } }
private async Task applyProjectionsAsync(IDocumentSession session, ICollection <EventProjection> projections, IEnumerable <TView> views) { var viewMap = createViewMap(session, projections, views); foreach (var eventProjection in projections) { var hasView = viewMap.TryGetValue(eventProjection.ViewId, out TView view); if (!hasView) { continue; } if (eventProjection.Type == ProjectionEventType.Delete) { if (await eventProjection.ShouldDelete(session, view)) { session.Delete(view); } } else { await eventProjection.ProjectTo(session, view); } } }
public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) using (IDocumentSession session = documentStore.OpenSession()) { var awsconfigs = session.GetAll <AWSInstanceConfiguration>(); var autobookconfigs = session.GetAll <AutoBookInstanceConfiguration>(); foreach (AutoBookInstanceConfiguration abic in autobookconfigs) { var aws = awsconfigs.Find(x => x.Id == abic.Id); if (aws != null) { abic.InstanceType = aws.InstanceType; abic.StorageSizeGb = aws.StorageSizeGb; abic.Cost = aws.Cost; } } awsconfigs.ForEach(aws => session.Delete(aws)); session.SaveChanges(); } } }
/// <summary> /// Method that delete an element of the repository. /// </summary> /// <typeparam name="DBType">Type of the element stored in the database. This is used to identify the collection</typeparam> /// <param name="id">Identifier of the element to delete.</param> /// <returns>RepositoryResponse.RepositoryDelete if the element has been successfully deleted, /// RepositoryResponse.RepositoryGenericError otherwise</returns> public override RepositoryResponse Delete <DBType>(string id) { lock (_store) { using (IDocumentSession _session = _store.OpenSession()) { var entity = _session.Load <DBType>(id); if (entity != null) { /*try * { * using (TransactionScope tx = new TransactionScope()) * {*/ _session.Delete <DBType>(entity); _session.SaveChanges(); // tx.Complete(); log.Debug("Data with id " + id + " deleted"); //} return(RepositoryResponse.RepositoryDelete); /*} * catch (TransactionAbortedException tae) * { * log.Error("Transaction Aborted", tae); * return RepositoryResponse.RepositoryGenericError; * }*/ } else { return(RepositoryResponse.RepositoryGenericError); } } } }
static void RenewUniqueness(IDocumentSession session, ISagaData sagaData) { var ids = GetUniquePropertyIdsFromMetaData(session, sagaData); var uniqueSagaProperties = session.Load <UniqueSagaProperty>(ids); var uniqueSagaPropertyIds = new List <string>(); foreach (var uniqueSagaProperty in uniqueSagaProperties) { var value = Reflect.Value(sagaData, uniqueSagaProperty.PropertyPath); var id = GetIdForUniqueProperty(sagaData.GetType(), uniqueSagaProperty.PropertyPath, value); var sagaDocumentId = session.Advanced.GetDocumentId(sagaData); if (id != uniqueSagaProperty.Id) { session.Delete(uniqueSagaProperty); session.Store(new UniqueSagaProperty { Id = id, PropertyPath = uniqueSagaProperty.PropertyPath, SagaId = sagaDocumentId }); } uniqueSagaPropertyIds.Add(id); } SetUniquePropertyIdsToMetaData(session, sagaData, uniqueSagaPropertyIds); }
/// <summary> /// Releases the mutex. /// </summary> private void Dispose(bool disposing) { if (_session != null && _lock != null) { try { _session.Delete(_lock); _session.SaveChanges(); } finally { _lock = null; } } if (_session != null) { _session.Dispose(); } if (disposing) { _session = null; } }
public void Execute(IDocumentSession session, IEnumerable <object> objects) { foreach (var document in objects.OfType <T>()) { session.Delete(document); } }
public static string ValidateUser(IDocumentSession ravenSession, string username, string password) { // try to get a user from the database that matches the given username and password var userRecord = ravenSession.Load<User>("users/" + username); if (userRecord == null) { return null; } // verify password var hashedPassword = GenerateSaltedHash(password, userRecord.Salt); if (!CompareByteArrays(hashedPassword, userRecord.Password)) return null; // cleanup expired or unusesd tokens foreach (var token in ravenSession.Query<ApiKeyToken>().Where(x => x.UserId == userRecord.Id)) { if (DateTimeOffset.UtcNow.Subtract(TimeSpan.FromDays(7)) > token.LastActivity) ravenSession.Delete(token); } // now that the user is validated, create an api key that can be used for subsequent requests var apiKey = Guid.NewGuid().ToString(); ravenSession.Store(new ApiKeyToken { UserId = userRecord.Id, SessionStarted = DateTimeOffset.UtcNow, LastActivity = DateTimeOffset.UtcNow }, GetApiKeyDocumentId(apiKey)); ravenSession.SaveChanges(); return apiKey; }
private bool ForwardCurrentBatch(IDocumentSession session, CancellationToken cancellationToken) { Log.Debug("Looking for batch to forward"); var nowForwarding = session.Include <RetryBatchNowForwarding, RetryBatch>(r => r.RetryBatchId) .Load <RetryBatchNowForwarding>(RetryBatchNowForwarding.Id); if (nowForwarding != null) { Log.DebugFormat("Loading batch {0} for forwarding", nowForwarding.RetryBatchId); var forwardingBatch = session.Load <RetryBatch>(nowForwarding.RetryBatchId); if (forwardingBatch != null) { Log.InfoFormat("Found batch {0}. Forwarding...", forwardingBatch.Id); Forward(forwardingBatch, session, cancellationToken); Log.DebugFormat("Retry batch {0} forwarded.", forwardingBatch.Id); } else { Log.WarnFormat("Could not find retry batch {0} to forward", nowForwarding.RetryBatchId); } Log.Debug("Removing Forwarding record"); session.Delete(nowForwarding); return(true); } Log.Debug("No batch found to forward"); return(false); }
private static void SetupTestData(IDocumentStore store) { new Product_AvailableForSale2().Execute(store); Product product1 = new Product("MyName1", "MyBrand1"); Product product2 = new Product("MyName2", "MyBrand2"); FacetSetup facetSetup = new FacetSetup { Id = "facets/ProductFacets", Facets = new List <Facet> { new Facet { FieldName = "Brand" } } }; using (IDocumentSession docSession = store.OpenSession()) { foreach (var productDoc in docSession.Query <Product>()) { docSession.Delete(productDoc); } docSession.SaveChanges(); docSession.Store(product1); docSession.Store(product2); docSession.Store(facetSetup); docSession.SaveChanges(); } }
public static void DeleteOwnerById(IDocumentStore store) { string id = NormalizeOwnerId(ReadNotEmptyString("Enter the Id of the owner to delete.")); double Num; bool isNum = double.TryParse(id, out Num); if (isNum) { Console.WriteLine(id); } else { Console.WriteLine("Invalid Number"); } using (IDocumentSession session = store.OpenSession()) { session.Delete(id); session.SaveChanges(); Console.WriteLine("Deleted user " + id); } PressAnyKeyToContinue(); }
private async Task applyProjectionsAsync(IDocumentSession session, ICollection <EventProjection> projections, IEnumerable <TView> views) { var idAssigner = session.Tenant.IdAssignmentFor <TView>(); var resolver = session.Tenant.StorageFor <TView>(); var viewMap = views.ToDictionary(view => (TId)resolver.IdentityFor(view), view => view); foreach (var eventProjection in projections) { var viewId = eventProjection.ViewId; var hasExistingView = viewMap.TryGetValue(viewId, out var view); if (!hasExistingView) { if (eventProjection.Type == ProjectionEventType.CreateAndUpdate) { view = newView(session.Tenant, idAssigner, viewId); viewMap.Add(viewId, view); hasExistingView = true; } } if (eventProjection.Type == ProjectionEventType.CreateAndUpdate || (eventProjection.Type == ProjectionEventType.UpdateOnly && hasExistingView)) { session.Store(view); eventProjection.ProjectTo(session, view).Wait(); } else if (eventProjection.Type == ProjectionEventType.Delete && hasExistingView && await eventProjection.ShouldDelete(session, view)) { session.Delete(view); } } }
public static string ValidateUser(IDocumentSession ravenSession, string username, string password) { // try to get a user from the database that matches the given username and password var userRecord = ravenSession.Load <User>("users/" + username); if (userRecord == null) { return(null); } // verify password var hashedPassword = GenerateSaltedHash(password, userRecord.Salt); if (!CompareByteArrays(hashedPassword, userRecord.Password)) { return(null); } // clear previous tokens foreach (var token in ravenSession.Query <ApiKeyToken>().Where(x => x.UserId == userRecord.Id)) { ravenSession.Delete(token); } // now that the user is validated, create an api key that can be used for subsequent requests var apiKey = Guid.NewGuid().ToString(); ravenSession.Store(new ApiKeyToken { UserId = userRecord.Id, SessionStarted = DateTimeOffset.UtcNow }, GetApiKeyDocumentId(apiKey)); ravenSession.SaveChanges(); return(apiKey); }
private void applyProjections(IDocumentSession session, ICollection <EventProjection> projections, IEnumerable <TView> views) { var viewMap = createViewMap(session, projections, views); foreach (var eventProjection in projections) { var hasView = viewMap.TryGetValue(eventProjection.ViewId, out TView view); if (!hasView) { continue; } using (Util.NoSynchronizationContextScope.Enter()) { if (eventProjection.Type == ProjectionEventType.Delete) { var shouldDeleteTask = eventProjection.ShouldDelete(session, view); shouldDeleteTask.Wait(); if (shouldDeleteTask.Result) { session.Delete(view); } } else { eventProjection.ProjectTo(session, view).Wait(); } } } }
public static void Delete(this Project project, IDocumentSession session) { session.Query<Activity>() .Where(a => a.Project == project.Id).ToList().ForEach(a => a.Delete(session)); session.Query<Discussion>() .Where(d => d.Entity == project.Id).ToList().ForEach(d => d.Delete(session)); session.Delete(project); }
/// <summary> /// delete an HRProcess and any assocoiated child tasks and meetings /// </summary> /// <param name="process"></param> /// <param name="session"></param> public static void DeleteProcessAndChildren(HRProcess process, IDocumentSession session) { var subject = session.Load<User>(process.Subject.UserId); subject.CurrentState = string.Empty; session.Delete(process); var childtasks = session.Query<Task>().Where(t => t.ParentItemId == process.Id); foreach (var t in childtasks) { session.Delete(t); } var childmeetings = session.Query<Meeting>().Where(t => t.ParentItemId == process.Id); foreach (var t in childmeetings) { session.Delete(t); } }
/// <summary> /// Deletes the user. /// </summary> /// <param name="ravenSession">The raven session.</param> /// <param name="id">The identifier.</param> /// <returns>The identifier of the deleted user.</returns> public string DeleteUser(IDocumentSession ravenSession, string id) { var currentDbModel = ravenSession.Load<User>(id); if (currentDbModel == null) { return null; } ravenSession.Delete<User>(currentDbModel); ravenSession.SaveChanges(); return id; }
public static IUserIdentity GetUserFromApiKey(IDocumentSession ravenSession, string apiKey) { if (apiKey == null) return null; var activeKey = ravenSession.Include<ApiKeyToken>(x => x.UserId).Load(GetApiKeyDocumentId(apiKey)); if (activeKey == null) return null; if (DateTimeOffset.UtcNow.Subtract(TimeSpan.FromDays(7)) > activeKey.LastActivity) { ravenSession.Delete(activeKey); ravenSession.SaveChanges(); return null; } activeKey.LastActivity = DateTimeOffset.Now; ravenSession.SaveChanges(); return ravenSession.Load<User>(activeKey.UserId); }
public TodoModule(IDocumentStore documentStore, IDocumentSession documentSession) : base("todo") { _documentStore = documentStore; _documentSession = documentSession; Get["/"] = _ => { return Response.AsJson<List<Todo>>(_documentSession.Query<Todo>().ToList()); }; Post["/"] = _ => { var todo = this.Bind<Todo>(); _documentSession.Store(todo); return Response.AsJson<Todo>(todo, HttpStatusCode.Created); }; Put["/"] = _ => { var todo = this.Bind<Todo>(); _documentSession.Store(todo); return Response.AsJson<Todo>(todo); }; Delete["/"] = _ => { var todo = this.Bind<Todo>(); todo = _documentSession.Load<Todo>(todo.Id); _documentSession.Delete<Todo>(todo); return Response.AsJson<Todo>(todo); }; }
private static void DeleteConfiguration(IDocumentSession session, string key) { var applicantsConfiguration = session.Load<dynamic>(key); if (applicantsConfiguration != null) session.Delete(applicantsConfiguration); }
public HomeModule(DataUploadHelper dataUploadHelper, IDocumentSession session, DropboxHelper dropboxHelper) { _dataUploadHelper = dataUploadHelper; _session = session; _dropboxHelper = dropboxHelper; Get["/"] = x => { TaskExecutor.DropboxHelper = _dropboxHelper; TaskExecutor.ExecuteTask(new DeleteDataMoreThanDayTask()); return View["index.html"]; }; Post["/fileupload"] = x => { var file = this.Request.Files.FirstOrDefault(); string dataId; try { if (file == null) { var str = Request.Form["data"].Value as string; dataId = _dataUploadHelper.UploadData(Request.Form["data"].Value as string); } else { dataId = _dataUploadHelper.UploadData(file.ContentType, file.Value, Path.GetExtension(file.Name)); } } catch (FileLoadException) { return HttpStatusCode.InsufficientStorage; } return dataId; }; Get["/view/datas/{Id}"] = x => { string id = x.Id.Value; Data data = _session.Load<Data>("datas/" + id); if (data == null) { return View["expire.html"]; } data.TimesView--; if (data.TimesView == 0) { if (data.Url != null && data.Url != string.Empty) { _dropboxHelper.DeleteFile(data.Url); } session.Delete<Data>(data); return View["expire.html"]; } if (data.ContentType == "text/plain" && data.Url == null || data.Url == string.Empty) return View["view", new { Data = data.Text, SessionId = Guid.NewGuid().ToString() }]; var fileBytes = _dropboxHelper.GetFile(data.Url); var memoryStream = new MemoryStream(fileBytes); return Response.FromStream(memoryStream, data.ContentType); }; }
private static void ImportFolder(string folderName, IDocumentSession session, string bookName = "") { Console.WriteLine("Importing folder " + folderName); Book book = null; if (!string.IsNullOrEmpty(bookName)) { var books = session.Query<Book>().Where(x => x.Name.Equals(bookName)).ToList(); book = books.FirstOrDefault(); if (book != null) { Console.WriteLine("Deleting book " + book.Name); session.Delete<Book>(book); } book = new Book() { Name = bookName }; session.Store(book); Console.WriteLine("Saved book " + book.Name); } foreach (var filePath in Directory.GetFiles(folderName)) { ImportFile(session, filePath, book); //File.Delete(filePath); } }
private static void PurgeSystemLog(IDocumentSession session) { bool done = false; int batchSize = 100; int totalDeleted = 0; while(!done) { var list = session.Query<SystemLog>() //.Customize(i=>i.WaitForNonStaleResultsAsOfNow()) .Take(batchSize); if(list.Count() < batchSize) { done = true; } foreach(var item in list) { session.Delete(item); totalDeleted++; } session.SaveChanges(); Console.WriteLine(totalDeleted.ToString() + " records deleted"); Debug.WriteLine(totalDeleted.ToString() + " records deleted"); } }
public static void Delete(this Activity activity,IDocumentSession session) { session.Query<Discussion>() .Where(d => d.Entity == activity.Id).ToList().ForEach(d => d.Delete(session)); session.Delete(activity); }
private static void Remove(IDocumentSession session, string subscriber, string messageType) { var subscription = session.Query<Subscription>() .Where(s => s.Subscriber == subscriber && s.MessageType == messageType).SingleOrDefault(); if (subscription != null) session.Delete(subscription); }
void Forward(RetryBatch forwardingBatch, IDocumentSession session) { var messageCount = forwardingBatch.FailureRetries.Count; if (isRecoveringFromPrematureShutdown) { returnToSender.Run(IsPartOfStagedBatch(forwardingBatch.StagingId)); } else if(messageCount > 0) { returnToSender.Run(IsPartOfStagedBatch(forwardingBatch.StagingId), messageCount); } session.Delete(forwardingBatch); Log.InfoFormat("Retry batch {0} done", forwardingBatch.Id); }
bool Stage(RetryBatch stagingBatch, IDocumentSession session) { var stagingId = Guid.NewGuid().ToString(); var matchingFailures = session.Load<FailedMessageRetry>(stagingBatch.FailureRetries) .Where(r => r != null && r.RetryBatchId == stagingBatch.Id) .ToArray(); var messageIds = matchingFailures.Select(x => x.FailedMessageId).ToArray(); if (!messageIds.Any()) { Log.InfoFormat("Retry batch {0} cancelled as all matching unresolved messages are already marked for retry as part of another batch", stagingBatch.Id); session.Delete(stagingBatch); return false; } var messages = session.Load<FailedMessage>(messageIds); foreach (var message in messages) { StageMessage(message, stagingId); } bus.Publish<MessagesSubmittedForRetry>(m => { m.FailedMessageIds = messages.Select(x => x.UniqueMessageId).ToArray(); m.Context = stagingBatch.Context; }); stagingBatch.Status = RetryBatchStatus.Forwarding; stagingBatch.StagingId = stagingId; stagingBatch.FailureRetries = matchingFailures.Select(x => x.Id).ToArray(); Log.InfoFormat("Retry batch {0} staged {1} messages", stagingBatch.Id, messages.Length); return true; }
bool ProcessBatches(IDocumentSession session) { var nowForwarding = session.Include<RetryBatchNowForwarding, RetryBatch>(r => r.RetryBatchId) .Load<RetryBatchNowForwarding>(RetryBatchNowForwarding.Id); if (nowForwarding != null) { var forwardingBatch = session.Load<RetryBatch>(nowForwarding.RetryBatchId); if (forwardingBatch != null) { Forward(forwardingBatch, session); } session.Delete(nowForwarding); return true; } isRecoveringFromPrematureShutdown = false; var stagingBatch = session.Query<RetryBatch>() .Customize(q => q.Include<RetryBatch, FailedMessageRetry>(b => b.FailureRetries)) .FirstOrDefault(b => b.Status == RetryBatchStatus.Staging); if (stagingBatch != null) { if (Stage(stagingBatch, session)) { session.Store(new RetryBatchNowForwarding { RetryBatchId = stagingBatch.Id }, RetryBatchNowForwarding.Id); } return true; } return false; }
public static void Delete(this Discussion discussion, IDocumentSession session) { session.Delete(discussion); }
public DinnerModuleAuth(IDocumentSession documentSession) : base("/dinners") { this.RequiresAuthentication(); Get["/create"] = parameters => { Dinner dinner = new Dinner() { EventDate = DateTime.Now.AddDays(7) }; base.Page.Title = "Host a Nerd Dinner"; base.Model.Dinner = dinner; return View["Create", base.Model]; }; Post["/create"] = parameters => { var dinner = this.Bind<Dinner>(); var result = this.Validate(dinner); if (result.IsValid) { UserIdentity nerd = (UserIdentity)this.Context.CurrentUser; dinner.HostedById = nerd.UserName; dinner.HostedBy = nerd.FriendlyName; RSVP rsvp = new RSVP(); rsvp.AttendeeNameId = nerd.UserName; rsvp.AttendeeName = nerd.FriendlyName; dinner.RSVPs = new List<RSVP>(); dinner.RSVPs.Add(rsvp); documentSession.Store(dinner); documentSession.SaveChanges(); return this.Response.AsRedirect("/dinners/" + dinner.DinnerID); } else { base.Page.Title = "Host a Nerd Dinner"; base.Model.Dinner = dinner; foreach (var item in result.Errors) { foreach (var member in item.MemberNames) { base.Page.Errors.Add(new ErrorModel() { Name = member, ErrorMessage = item.GetMessage(member) }); } } } return View["Create", base.Model]; }; Get["/delete/" + Route.AnyIntAtLeastOnce("id")] = parameters => { Dinner dinner = documentSession.Load<Dinner>((int)parameters.id); if (dinner == null) { base.Page.Title = "Nerd Dinner Not Found"; return View["NotFound", base.Model]; } if (!dinner.IsHostedBy(this.Context.CurrentUser.UserName)) { base.Page.Title = "You Don't Own This Dinner"; return View["InvalidOwner", base.Model]; } base.Page.Title = "Delete Confirmation: " + dinner.Title; base.Model.Dinner = dinner; return View["Delete", base.Model]; }; Post["/delete/" + Route.AnyIntAtLeastOnce("id")] = parameters => { Dinner dinner = documentSession.Load<Dinner>((int)parameters.id); if (dinner == null) { base.Page.Title = "Nerd Dinner Not Found"; return View["NotFound", base.Model]; } if (!dinner.IsHostedBy(this.Context.CurrentUser.UserName)) { base.Page.Title = "You Don't Own This Dinner"; return View["InvalidOwner", base.Model]; } documentSession.Delete(dinner); documentSession.SaveChanges(); base.Page.Title = "Deleted"; return View["Deleted", base.Model]; }; Get["/edit" + Route.And() + Route.AnyIntAtLeastOnce("id")] = parameters => { Dinner dinner = documentSession.Load<Dinner>((int)parameters.id); if (dinner == null) { base.Page.Title = "Nerd Dinner Not Found"; return View["NotFound", base.Model]; } if (!dinner.IsHostedBy(this.Context.CurrentUser.UserName)) { base.Page.Title = "You Don't Own This Dinner"; return View["InvalidOwner", base.Model]; } base.Page.Title = "Edit: " + dinner.Title; base.Model.Dinner = dinner; return View["Edit", base.Model]; }; Post["/edit" + Route.And() + Route.AnyIntAtLeastOnce("id")] = parameters => { Dinner dinner = documentSession.Load<Dinner>((int)parameters.id); if (!dinner.IsHostedBy(this.Context.CurrentUser.UserName)) { base.Page.Title = "You Don't Own This Dinner"; return View["InvalidOwner", base.Model]; } this.BindTo(dinner); var result = this.Validate(dinner); if (!result.IsValid) { base.Page.Title = "Edit: " + dinner.Title; base.Model.Dinner = dinner; foreach (var item in result.Errors) { foreach (var member in item.MemberNames) { base.Page.Errors.Add(new ErrorModel() { Name = member, ErrorMessage = item.GetMessage(member) }); } } return View["Edit", base.Model]; } documentSession.SaveChanges(); return this.Response.AsRedirect("/" + dinner.DinnerID); }; Get["/my"] = parameters => { string nerdName = this.Context.CurrentUser.UserName; var userDinners = documentSession.Query<Dinner, Dinners_Index>() .Where(x => x.HostedById == nerdName || x.HostedBy == nerdName || x.RSVPs.Any(r => r.AttendeeNameId == nerdName || (r.AttendeeNameId == null && r.AttendeeName == nerdName))) .OrderBy(x => x.EventDate) .AsEnumerable(); base.Page.Title = "My Dinners"; base.Model.Dinners = userDinners; return View["My", base.Model]; }; }
public void Leave(string roomName, IDocumentSession session = null) { //using (var session = store.OpenSession()) var isExternalSession = session == null; if (session == null) session = store.OpenSession(); try { if (!joinedRooms.Any(r => r.Name.Equals(roomName, StringComparison.InvariantCultureIgnoreCase))) { Console.WriteLine("Cannot leave because not joined.."); return; } var roomToLeave = session.Load<Room>($"rooms/{roomName}"); if (roomToLeave != null) { roomToLeave.Users.Remove($"users/{username}"); if (roomToLeave.Users.Count == 0) //room is empty - no need to keep it { var idsToDelete = new List<string>(); using (var stream = session.Advanced.Stream( session.Query<Message, MessagesByRoomIndex>())) { do { if(stream.Current != null) session.Delete(stream.Current.Key); } while (stream.MoveNext()); } session.Delete(roomToLeave); } } joinedRooms.RemoveAt(joinedRooms.FindIndex(r => r.Id == roomToLeave.Id)); session.SaveChanges(); Console.WriteLine($"Left room {roomName}"); } finally { if (isExternalSession) session.Dispose(); } }