public async Task relationships_work()
{
await DB.InitAsync(dbName);
DB.DatabaseFor <BookCover>(dbName);
DB.DatabaseFor <BookMark>(dbName);
var cover = new BookCover
{
BookID = "123",
BookName = "test book " + Guid.NewGuid().ToString()
};
await cover.SaveAsync();
var mark = new BookMark
{
BookCover = cover.ToReference(),
BookName = cover.BookName,
};
await mark.SaveAsync();
await cover.BookMarks.AddAsync(mark);
var res = await cover.BookMarks.ChildrenQueryable().FirstAsync();
Assert.AreEqual(cover.BookName, res.BookName);
Assert.AreEqual((await res.BookCover.ToEntityAsync()).ID, cover.ID);
}
public MineLoopState(string command)
{
List <string> args = new List <string>(command.Split(' '));
// "mineloop <Base bm> <Mining bm> <maxcount>"
if (args.Count == 4)
{
BookMark base_bm = g.eve.Bookmark(args[1]);
BookMark mining_bm = g.eve.Bookmark(args[2]);
if (base_bm != null && base_bm.IsValid &&
mining_bm != null && mining_bm.IsValid)
{
base_label = base_bm.Label;
mining_label = mining_bm.Label;
max_count = Int32.Parse(args[3]);
}
else
{
SetDone("Bookmark not found");
}
}
else
{
SetDone("Invalid arguments");
}
}
public BookMark AddBookMark(BookMark bookMark)
{
var result = unitOfWork.BookMarkRepository.Insert(bookMark);
unitOfWork.Save();
return(result);
}
public DoDropoffState(string command)
{
List <string> args = new List <string>(command.Split(' '));
// "dodropoff <Base bm> <Mining bm>"
if (args.Count == 3)
{
BookMark base_bm = g.eve.Bookmark(args[1]);
BookMark mining_bm = g.eve.Bookmark(args[2]);
if (base_bm != null && base_bm.IsValid &&
mining_bm != null && mining_bm.IsValid)
{
base_label = base_bm.Label;
mining_label = mining_bm.Label;
}
else
{
SetDone("Bookmark not found");
}
}
else
{
SetDone("Invalid arguments");
}
}
private void AddBookMark(object sender)
{
foreach (var x in Book.BookMarks)
{
x.EntityState = EntityState.Unchanged;
}
foreach (var publisher in Book.Publishers)
{
publisher.EntityState = EntityState.Unchanged;
}
foreach (var author in Book.Authors)
{
author.EntityState = EntityState.Unchanged;
}
var b = new BookMark
{
Book = Book,
BookMarkedPage = PdfPanel.GetCurrentPageNumber(),
EntityState = EntityState.Added
};
Book.BookMarks.Add(b);
new BookDomain().UpdateBook(Book);
Refresh();
}
private void updateMark()
{
if (mMarkAdapter == null)
{
mMarkAdapter = new BookMarkAdapter(this, new List <BookMark>());
lvMark.Adapter = (mMarkAdapter);
lvMark.ItemClick += (sender, e) => {
BookMark mark = mMarkAdapter.getData(e.Position);
if (mark != null)
{
mPageWidget.setPosition(new int[] { mark.chapter, mark.startPos, mark.endPos });
hideReadBar();
}
else
{
ToastUtils.showSingleToast("书签无效");
}
};
}
mMarkAdapter.clear();
mMarkList = Settings.GetBookMarks(bookId);
if (mMarkList != null && mMarkList.Count() > 0)
{
mMarkList.Reverse();
mMarkAdapter.addAll(mMarkList);
}
}
/// Moves the cursor to a specific position in the table.
/// </summary>
/// <param name="bookMark">The bookmark identifying the starting position for the seek operation.</param>
/// <param name="rowCount">The signed count of the number of rows to move, starting from the bookmark.</param>
/// <returns></returns>
public bool SeekRow(BookMark bookMark, int rowCount)
{
IntPtr pRowsSought;
HRESULT hResult = tb_.SeekRow((int)bookMark, rowCount, out pRowsSought);
return(hResult == HRESULT.S_OK);
}
public BookMark UpdateBookMark(BookMark bookMark)
{
var result = _opfcUow.BookMarkRepository.UpdateBookMark(bookMark);
_opfcUow.Commit();
return(result);
}
public async Task <IHttpActionResult> PostBookMark(BookMark bookMark)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.BookMarks.Add(bookMark);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (BookMarkExists(bookMark.BookmarkId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = bookMark.BookmarkId }, bookMark));
}
public async Task <bool> BookMarkActivity(int attendesID, int activityId)
{
if (Db.BookMarks.Any(x => x.AttendesID == attendesID && activityId == x.ActivityID))
{
var bookmark = Db.BookMarks.FirstOrDefault(x => x.AttendesID == attendesID && x.ActivityID == activityId);
Db.BookMarks.Remove(bookmark);
await Db.SaveChangesAsync();
}
else
{
try
{
BookMark bm = new BookMark
{
ActivityID = activityId,
AttendesID = attendesID
};
Db.BookMarks.Add(bm);
//Db.BookMarks.Add(new BookMark
//{
// AttendesID = attendesID,
// ActivityID = activityId,
//});
await Db.SaveChangesAsync();
}
catch (Exception ex)
{
}
}
return(true);
}
public async Task <IHttpActionResult> PutBookMark(string id, BookMark bookMark)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != bookMark.BookmarkId)
{
return(BadRequest());
}
db.Entry(bookMark).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookMarkExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void relationships_work()
{
var cover = new BookCover
{
BookID = "123",
BookName = "test book " + Guid.NewGuid().ToString()
};
cover.Save();
var mark = new BookMark
{
BookCover = cover.ToReference(),
BookName = cover.BookName,
};
mark.Save();
cover.BookMarks.Add(mark);
var res = cover.BookMarks.ChildrenQueryable().First();
Assert.AreEqual(cover.BookName, res.BookName);
Assert.AreEqual(res.BookCover.ToEntity().ID, cover.ID);
}
private void AddBookMarkInDB()
{
if (this.currentBook != null)
{
DatabaseContext context = new DatabaseContext();
var currentBook = context.Books.Where(i => i.Id == this.currentBook.Id)?.FirstOrDefault();
if (currentBook != null && audioFileReader != null)
{
BookMark bookMark = new BookMark();
bookMark.BookId = currentBook.Id;
bookMark.Description = currentBook.Title;
var timeInMS = audioFileReader.CurrentTime.TotalMilliseconds;
bookMark.TimeInMS = timeInMS > TimeSpan.FromSeconds(2).TotalMilliseconds ? timeInMS - TimeSpan.FromSeconds(1).TotalMilliseconds : timeInMS;
if (currentBook != null)
{
context.BookMarks.Add(bookMark);
context.SaveChanges();
LoadBookMarks(currentBook.Id);
}
}
}
}
public SearchViewModel(BibleViewModel vm)
{
outerViewModel = vm;
dataAccess = BibleDataAccess.Instance();
SearchPages = new ObservableCollection <SearchModel>();
PageChangedCommand = new Command <int>(PageChanged);
BookMark bookMark = dataAccess.GetBookMark();
Book = bookMark.book;
Chapter = bookMark.chapter;
int[] indexInfo = dataAccess.GetIndexCount(bookMark.book, bookMark.chapter);
for (int i = 0; i < 3; i++)
{
SearchModel model = new SearchModel(this);
if (i >= 1)
{
model.Items = GetGridItem(indexInfo[i - 1]);
model.Position = i;
}
else
{
model.Items = dataAccess.GetBibleNames();
model.Position = i;
}
SearchPages.Add(model);
}
}
static void Main(string[] args)
{
VTDGen vg = new VTDGen();
int i;
AutoPilot ap = new AutoPilot();
ap.selectXPath("/CATALOG/CD[PRICE < 10]");
BookMark bm = new BookMark();
if (vg.parseFile("cd.xml", false))
{
VTDNav vn = vg.getNav();
bm.bind(vn);
ap.bind(vn);
//XPath eval returns one node at a time
while ((i = ap.evalXPath()) != -1)
{
// push the current cursor position
//vn.push();
bm.recordCursorPosition(); // equivalent to vn.push();
// get to the first child
if (vn.toElement(VTDNav.FIRST_CHILD, "TITLE"))
{
int j = vn.getText();
if (j != -1)
Console.WriteLine(" text node ==>" + vn.toString(j));
}
// restore the cursor position
//vn.pop();
bm.setCursorPosition(); // equivalent to vn.pop();
}
ap.resetXPath();
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.article_detail);
FindViewById <TextView>(Resource.Id.head_title).Text = "收藏详情";
bookMark = JsonConvert.DeserializeObject <BookMark>(Intent.GetStringExtra("bookMark"));
bindControls();
}
public async void Remove(BookMark bookmark)
{
using (var ctx = new Context())
{
ctx.Bookmarks.Attach(bookmark);
ctx.Bookmarks.Remove(bookmark);
await ctx.SaveChangesAsync();
}
}
void img_MouseEnter(object sender, MouseEventArgs e)
{
BookMark bookMark = ((sender as Image).Tag) as BookMark;
selectedBookMark = bookMark;
TextBlockBookMarkHeader.Text = bookMark.Header;
TextBlockBookMarkText.Text = bookMark.Text;
popBookmark.IsOpen = true;
}
public int SeekRow(BookMark bookmark, int crowsSeek)
{
int result = 0;
this.MapiSession.InvokeWithWrappedException(delegate()
{
result = this.mapiTable.SeekRow(bookmark, crowsSeek);
}, Strings.ErrorMapiTableSeekRow(this.mapiObjectId.ToString(), this.MapiSession.ServerName), this.mapiObjectId);
return(result);
}
public async Task <BookMark> AddAsync(BookMark book)
{
using (var ctx = new Context())
{
var added = ctx.Bookmarks.Add(book);
await ctx.SaveChangesAsync();
return(added.Entity);
}
}
private bool AtHomeStation()
{
BookMark bm = g.eve.Bookmark(base_label);
if (g.me.InStation &&
g.me.StationID == bm.ItemID)
{
return(true);
}
return(false);
}
public async Task <IHttpActionResult> GetBookMark(string id)
{
BookMark bookMark = await db.BookMarks.FindAsync(id);
if (bookMark == null)
{
return(NotFound());
}
return(Ok(bookMark));
}
public void SetBookmark(BookMark bookMark)
{
_bookmark = bookMark;
FlowDocument mcFlowDoc = new FlowDocument();
// Create a paragraph with text
Paragraph block = new Paragraph(new Run(_bookmark.Description));
mcFlowDoc.Blocks.Add(block);
txtDescBM.Document = mcFlowDoc;
}
//
// GET: /Bookmark/Details/5
public ActionResult Details(Guid id)
{
if (!Authorization.GetAccess(table, HttpContext.User.Identity.Name, read))
{
return(RedirectToAction("Index", "Home"));
}
BookMark bookmark = db.BookMarks.Single(b => b.ID == id && (b.IsDeleted == null || b.IsDeleted == false));
return(View(bookmark));
}
public async Task <IHttpActionResult> GetBookMark(int id)
{
BookMark bookMark = await db.Bookmarks.FindAsync(id);
if (bookMark == null)
{
return(NotFound());
}
var currentUser = User.Identity.GetUserId();
return(Ok(db.Bookmarks.Where(o => (o.Public == true) || (o.OwnerId == currentUser))));
}
public static double Distance(this BookMark bookmark)
{
if (bookmark.ToEntity.IsValid)
{
return(bookmark.ToEntity.Distance);
}
else
{
var me = g.me.ToEntity;
return(Distance(me.X, me.Y, me.Z, bookmark.X, bookmark.Y, bookmark.Z));
}
}
public static void SafeSpot(BookMark SafeSpotBkmk, bool Align)
{
VNI.DebugUI.NewConsoleMessage("Warping To Safespot: " + SafeSpotBkmk.Label);
if (!Align)
{
SafeSpotBkmk.WarpTo();
}
if (Align)
{
SafeSpotBkmk.AlignTo();
}
}
//
// GET: /Bookmark/Edit/5
public ActionResult Edit(Guid id)
{
if (!Authorization.GetAccess(table, HttpContext.User.Identity.Name, write))
{
return(RedirectToAction("Index", "Home"));
}
BookMark bookmark = db.BookMarks.Single(b => b.ID == id && (b.IsDeleted == null || b.IsDeleted == false));
ViewBag.CreatedBy = new SelectList(db.Users, "ID", "UserName", bookmark.CreatedBy);
ViewBag.ModifiedBy = new SelectList(db.Users, "ID", "UserName", bookmark.ModifiedBy);
return(View(bookmark));
}
public async Task <IHttpActionResult> DeleteBookMark(string id)
{
BookMark bookMark = await db.BookMarks.FindAsync(id);
if (bookMark == null)
{
return(NotFound());
}
db.BookMarks.Remove(bookMark);
await db.SaveChangesAsync();
return(Ok(bookMark));
}
private void MenuItemAddBookMark_Click(object sender, RoutedEventArgs e)
{
if (ScaleManager.EndTime == 0)
{
return;
}
BookMark bm = new BookMark("<header>", "<text>", Variable.FullName, CursorViewer.Time);
BookMarkProperties bmp = new BookMarkProperties(bm);
if (bmp.ShowDialog() == true)
{
Core.BookMarks.Add(bm);
}
}
private void AddBookMark(object sender)
{
foreach (var x in Book.BookMarks)
{
x.EntityState = EntityState.Unchanged;
}
foreach (var publisher in Book.Publishers)
{
publisher.EntityState = EntityState.Unchanged;
}
foreach (var author in Book.Authors)
{
author.EntityState = EntityState.Unchanged;
}
var b = new BookMark
{
Book = Book,
BookMarkedPage = PdfPanel.GetCurrentPageNumber(),
EntityState = EntityState.Added
};
Book.BookMarks.Add(b);
new BookDomain().UpdateBook(Book);
Refresh();
}