/// <summary> /// Saves given user to db. /// </summary> /// <param name="nickname">New user nickname.</param> /// <returns>New user object.</returns> public static User Save(string nickname) { using (var db = new LiteRepository(@"MyData.db")) { User newUser = new User { Id = System.Guid.NewGuid(), Nickname = nickname }; db.Insert <User>(newUser); return(newUser); } }
/// <summary> /// Saves given chat room and returns latest chat room list. /// </summary> /// <param name="chatRoomName">Chat room name.</param> /// <returns>Latest chat room list.</returns> public static List <ChatRoom> SaveAndGetLatestChatRoomList(string chatRoomName) { using (var db = new LiteRepository(@"MyData.db")) { ChatRoom newChatRoom = new ChatRoom { Id = System.Guid.NewGuid(), Name = chatRoomName }; db.Insert <ChatRoom>(newChatRoom); return(db.Query <ChatRoom>().ToList()); } }
private void Flush() { var logs = _cache.ToArray(); _cache.Clear(); Task.Factory.StartNew(() => { _db.Insert((IEnumerable <Log>)logs, "EventLog"); }); }
public void Write(Person person) { try { repository.Insert(person); } catch (LiteException) { repository.Update(person); } }
public void Write(Poster poster) { try { repository.Insert(poster); } catch (LiteException) { repository.Update(poster); } }
public void Should_query_by_literal_guid() { var g = new Guid("CFF4EF1C-A0DB-4F0C-B1DE-FCFEC7028CFF"); using var repo = new LiteRepository(dbFile).WithUtcDate(); repo.Insert(new Entity { Id = g, Data = "123" }); var e = repo.Query <Entity>().Where($"_id = GUID('{g}')").First(); e.Data.Should().Be("123"); }
public Result <bool> Insert(T entity, string collectionName = null) { var result = new Result <bool>(); try { _liteRepository.Insert(entity, collectionName); result.ResultObject = true; } catch (Exception ex) { result.ResultObject = false; result.ResultCode = (int)ResultStatusCode.InternalServerError; result.ResultMessage = "Hata OluÅŸtu => " + ex; result.ResultInnerMessage = "Hata OluÅŸtu => " + ex.InnerException; result.ResultStatus = false; } return(result); }
public void Should_query_bson_document() { var g = new Guid("CFF4EF1C-A0DB-4F0C-B1DE-FCFEC7028CFF"); using var repo = new LiteRepository(dbFile).WithUtcDate(); repo.Insert(new Entity { Id = g, Data = "123" }); var doc = repo.Query <BsonDocument>("Entity").Where($"_id = GUID('{g}')").First(); doc["Data"].AsString.Should().Be("123"); }
public void Create(IEnumerable <PvpApiRowModel> ladderRows) { if (ladderRows == null) { throw new ArgumentNullException(nameof(ladderRows)); } foreach (PvpApiRowModel row in ladderRows) { _liteDbRepo.Insert(row); } }
public Security GetSecurity() { var security = _repository.FirstOrDefault <Security>(); if (security != null) { return(security); } security = new Security(); _repository.Insert(security, "security"); return(security); }
public void Should_generate_guid_id() { using var repo = new LiteRepository(dbFile).WithUtcDate(); var entity = new Entity { Data = "123" }; repo.Insert(entity); var e = repo.Query <Entity>().Where(x => x.Id == entity.Id).First(); e.Data.Should().Be("123"); e.Id.Should().NotBe(Guid.Empty); }
/// <summary> /// Saves new message and List Last 30 messages sent to given chat room. /// </summary> /// <param name="user">User name.</param> /// <param name="message">Message information.</param> /// <param name="chatRoom">Chat room.</param> /// <returns></returns> public static List <Message> SaveMessageAndListLastThirtyMessages(string user, string message, string chatRoom) { using (var db = new LiteRepository(@"MyData.db")) { Message newMessage = new Message { Id = System.Guid.NewGuid(), MessageText = message, Sender = user, ChatRoom = chatRoom, SentTime = DateTime.Now }; db.Insert <Message>(newMessage); db.Database.GetCollection <Message>().EnsureIndex("ChatRoom"); var messages = db.Query <Message>().Where(x => x.ChatRoom == chatRoom).ToList(); return(messages.OrderByDescending(x => x.SentTime).Take(30).ToList()); } }
private void AddTagIfNotExists(IEnumerable <TagDto> tags) { using (var db = new LiteRepository(_connectionString)) { foreach (var tag in tags) { var exists = db.FirstOrDefault <TagDto>(x => x.NormalizedName == tag.NormalizedName); if (exists == null) { db.Insert <TagDto>(tag); } } } }
public Order CreateNewOrder(List <OrderItem> model) { using (var db = new LiteRepository(connectionString)) { var newOrder = new Order { OrderNumber = Guid.NewGuid(), Status = "Pending", Items = model }; db.Insert <Order>(newOrder); return(newOrder); } }
public async Task AddEvent(Event eEvent) { // Create & insert event into DB eEvent.Created = DateTimeOffset.Now; _db.Insert(eEvent); // Notify Users var list = await PermissionCheck(SimplePermissionType.PublishEvents); await _nService.NotifyUsers(new Notification { Message = _localizer["createEventMessage", eEvent.Author, eEvent.TakesPlace], Subject = _localizer["createEventSubject", eEvent.Name] }, list); }
public void Read_bson_with_more_fields_then_entity() { using var repo = new LiteRepository(dbFile).WithUtcDate(); repo.Insert(new BigEntity { Field1 = "111", Field2 = "222" }, "col"); var e = repo.Query <SmallEntity>("col").First(); e.Field1.Should().Be("111"); repo.Update(e, "col"); var e2 = repo.Query <BigEntity>("col").First(); e2.Field1.Should().Be("111"); e2.Field2.Should().BeNullOrEmpty(); }
public UserModel Create(UserModel model) { if (model == null) { throw new ArgumentNullException(nameof(model)); } if (!string.IsNullOrWhiteSpace(model.Password)) { model.Password = BCrypt.Net.BCrypt.HashPassword(model.Password); } _instance.Insert <UserModel>(model); return(model); }
public void Should_insert_new_bson_document_with_guid_id() { using var repo = new LiteRepository(dbFile).WithUtcDate(); var collection = repo.Database.GetCollection("Entity", BsonAutoId.Guid); var doc = new BsonDocument { ["Data"] = "666" }; collection.Upsert(doc); repo.Insert(new Entity { Data = "555" }); var docs = repo.Query <Entity>().ToList(); docs.Should().OnlyContain(x => x.Id != Guid.Empty); }
public void Read_untyped_object() { using var repo = new LiteRepository(dbFile).WithUtcDate(); var custom = new SmallEntity { Id = Id <SmallEntity> .NewId(), Field1 = "ffff" }; repo.Insert(new BigEntity { Field1 = "111", Field2 = "222", Custom = custom }); var e = repo.Query <BigEntity>().First(); var custom2 = e.Custom.Should().BeOfType <SmallEntity>().Subject; custom2.Id.Should().Be(custom.Id); custom2.Field1.Should().Be(custom.Field1); }
public void Should_insert_many_documents(int count) { var cts = new CancellationTokenSource(TimeSpan.FromSeconds(180)); var token = cts.Token; using var repo = new LiteRepository(dbFile).WithUtcDate(); for (var i = 0; i < count; i++) { repo.Insert(new Entity { Data = i.ToString() }); if (token.IsCancellationRequested) { break; } } }
public async Task <ActionResult> Create([FromBody] Event hggEvent) { var user = await _userManager.GetUserAsync(HttpContext.User); hggEvent.Author = user; if (ModelState.IsValid) { _db.Insert(hggEvent); return(Json("OK")); //return RedirectToAction(nameof(PublishedIndex)); } return(BadRequest()); }
public ActionResult Create([Bind("TagName")] Tag tag) { if (ModelState.IsValid) { db.Insert(tag); _audit.Add(new TagAudit() { Tag = tag.TagName, TagId = tag.Id.ToString(), Type = "created", User = _userManager.GetUserName(User), UserId = _userManager.GetUserId(User) }); return(RedirectToAction(nameof(Index))); } return(View()); }
private static void EnsurePdfFile(this LiteRepository repo, PdfFile value, bool updateLastSeen = true) { var pdf = repo.GetPdf(value.Md5); if (pdf == null) { value.Id = (Guid)repo.Insert <PdfFile>(value); } else { value.Id = pdf.Id; } if (updateLastSeen) { value.LastSeen = DateTime.Now; } repo.Update(value); }
public async Task Handle(SubmitOrder message, IMessageHandlerContext context) { log.Info($"Order arrived for movie {message.Movie}"); var movie = db.Query <Movie>() .Where(s => s.Id == message.Movie) .SingleOrDefault(); if (movie == null) { throw new ArgumentException($"Movie {message.Movie} not found in datastore", nameof(message.Movie)); } var order = new Order { Id = Guid.NewGuid(), MovieIdentifier = message.Movie, TheaterIdentifier = message.Theater, UserIdentifier = message.UserId, MovieTime = message.Time, NumberOfTickets = message.NumberOfTickets }; bool immediatelyApproved = movie.TicketType != TicketType.DrawingTicket; await context.Reply(new OrderSubmission() { OrderId = Guid.NewGuid(), Movie = message.Movie, MovieTime = message.Time, Theater = message.Theater, NumberOfTickets = message.NumberOfTickets, Approved = immediatelyApproved, }); // We could prevent publishing if it's a TicketType.DrawingTicket. // But what if in the future we do want to get notified? We'd have to change this handler again. // So let's put it in right now! :-) await context.Publish(new OrderAccepted(order.Id)); // Insert last because it's a non-transactional resource that cannot easily be rolled back. db.Insert(order); }
public void Should_serialize_and_deserialize_to_litedb() { using var repo = new LiteRepository(dbFileName).WithUtcDate(); var cls = new Class { Id = Id <Class> .NewId(), Name = "Class1" }; var rider = new Rider { Id = Id <Rider> .NewId(), Name = "Rider1", ClassId = cls.Id }; repo.Insert(cls); repo.Upsert(rider); repo.Upsert(rider); repo.Query <Rider>().Count().Should().Be(1); var persistedRider = repo.Query <Rider>().Where(x => x.Id == rider.Id).First(); persistedRider.Name.Should().Be("Rider1"); var persistedClass = repo.Query <Class>().Where(x => x.Id == persistedRider.ClassId).First(); persistedClass.Name.Should().Be("Class1"); }
IError IDataService.InsertItemActive(IItemActive item) { IError error = ErrorInit(); try { repo.Insert((ItemActive)item); return(error); } catch (Exception ex) { error = Helpers.ErrorMessage(ErrorType.NoUniqueID, ex.Message); errorService.Write(error); return(error); } }
public void Gravar(Registro registro) { EnsureNotDisposed(); var ehTransiente = EhTransiente(registro.Id); if (ehTransiente) { int id = registro.Id; BsonValue result; result = _repositorio.Insert(registro, ColecaoRegistros); _repositorio.Database.GetCollection <Registro>(ColecaoRegistros) .EnsureIndex(reg => reg.Id, true); registro.Id = result.AsInt32; ExcluirTransiente(id); } else { _repositorio.Update(registro, ColecaoRegistros); } }
public IObservable <Tuple <OperationResult, TimeEntry> > EnterNewCustomTimeEntry(DateTime start, DateTime end) { TimeEntry entry = null; return(Observable.Start(() => { if ((end - start).TotalHours < 0) { return new Tuple <OperationResult, TimeEntry>(OperationResult.EndedBeforeItStarted, null); } if (end.Date.DayOfWeek != start.Date.DayOfWeek) { return new Tuple <OperationResult, TimeEntry>(OperationResult.DifferenceBetweenDatesTooBig, null); } var id = repo.Insert <TimeEntry>(entry = new TimeEntry { EntryTimeEnd = end, EntryTimeStart = start }); entry.Id = id; return new Tuple <OperationResult, TimeEntry>(OperationResult.OK, entry); }, Scheduler.ThreadPool)); }
public void Insert(T item) { var s = _liteRepository.Insert(item); }
public void Add(ModuleSettingsEntity moduleSettingsEntity) { _repository.Insert(moduleSettingsEntity); }