public ActionResult GetPageListJson(Pagination pagination, string queryJson)
{
var watch = CommonHelper.TimerStart();
SettingsEntity para = new SettingsEntity();
if (!string.IsNullOrWhiteSpace(queryJson))
{
var queryParam = queryJson.ToJObject();
//类型
if (!queryParam["condition"].IsEmpty() && !queryParam["keyword"].IsEmpty())
{
var condition = queryParam["condition"].ToString().ToLower();
switch (condition)
{
case "name":
para.Name = queryParam["keyword"].ToString();
break;
}
}
}
var pageList = SettingsBLL.Instance.GetPageList(para, ref pagination);
var JsonData = new
{
rows = pageList,
total = pagination.total,
page = pagination.page,
records = pagination.records,
costtime = CommonHelper.TimerEnd(watch)
};
return(Content(JsonData.ToJson()));
}
public void TestSettingsProperties()
{
var settingsRepo = Container.Resolve <SettingsRepository>();
var entryRepo = Container.Resolve <SettingsEntryRepository>();
var datetime = DateTime.Now;
var settings = new SettingsEntity("testSettingProps");
settings.SetEntry("str", "stringvalue");
settings.SetEntry("int", 10);
settings.SetEntry("double", 10.4);
settings.SetEntry("bit", true);
settings.SetEntry("date", datetime);
settingsRepo.SaveOrUpdate(settings);
var e = entryRepo.GetEntryByKey(settings, "str");
settings = settingsRepo.Load(settings.Id);
Assert.IsNotNull(settings);
var date = settings["date"].GetValue <DateTime>();
Assert.AreEqual(datetime.ToString(), date.ToString());
}
public ActionResult MemberInfo()
{
string strId = Request.QueryString["id"];
Guid id = Guid.Empty;
if (String.IsNullOrEmpty(strId) || Guid.TryParse(strId, out id) == false)
{
//TODO:ID无效
//return RedirectToAction("PointCommodity", new { domain = domain });
}
MemberInfoViewModel model = new MemberInfoViewModel();
model.MemberCardLevelList = _memberManager.GetMemberCardList(DomainContext.Domain.Id, DomainContext.AppId);
model.Member = _memberManager.GetMember(id);
if (model.Member.CardLevel.HasValue)
{
model.MemberCard = _memberManager.GetMemberCard(model.Member.CardLevel.Value);
}
else
{
SettingsEntity settings = DomainContext.Settings;
if (settings != null && settings.DefaultMemberCardLevel.HasValue)
{
model.MemberCard = _memberManager.GetMemberCard(settings.DefaultMemberCardLevel.Value);
}
}
return(View(model));
}
public SettingsModel()
{
_entity = new SettingsEntity
{
Id = Guid.NewGuid()
};
}
public SettingsEntity GetSettings(Guid domainId, string appId)
{
if (String.IsNullOrEmpty(appId))
{
return(null);
}
SettingsEntity settings = new SettingsEntity();
settings.Domain = domainId;
settings.AppId = appId;
if (_dataBase.Fill <SettingsEntity>(settings) == false)
{
lock (_settingsLockObj)
{
if (_dataBase.Fill <SettingsEntity>(settings) == false)
{
//初始化一条默认设置
_dataBase.Insert(settings);
}
}
}
return(settings);
}
public void BoxOfSettingsEntityTest()
{
IContainer container = Container;
var repo = container.Resolve <SettingsRepository>();
var s = repo.Get(1);
if (s == null)
{
s = new SettingsEntity()
{
Name = "testsetting"
};
s.AddEntry("asd", "ddd");
repo.Save(s);
}
var transformer = container.Resolve <NHibernateBoxTransformation <SettingsBoxMap, SettingsEntity> >();
transformer.Entries = new[] { s };
var boxed = transformer.ToBox();
var xmlBoxer = new XmlBoxPresentation <SettingsBoxMap>();
var ss = xmlBoxer.AsString(boxed);
var box = xmlBoxer.FromString(ss);
Assert.IsTrue(box.First().Name == s.Name);
Assert.AreEqual(s.Entries.First().Name, box.First().Entries.First().Name);
}
public ActionResult SaveForm(string keyValue, SettingsEntity entity)
{
try
{
entity.Remark = entity.Remark == null ? "" : entity.Remark.Replace("&", "&").Replace(">", ">").Replace("<", "<");
if (keyValue != "")
{
entity.SettingId = keyValue;
SettingsBLL.Instance.Update(entity);
}
else
{
entity.SettingId = Util.Util.NewUpperGuid();
SettingsBLL.Instance.Add(entity);
}
return(Success("保存成功"));
}
catch (Exception ex)
{
ex.Data["Method"] = "SettingsController>>SaveForm";
new ExceptionHelper().LogException(ex);
return(Error("保存失败"));
}
}
private void Adminka_Load(object sender, EventArgs e)
{
_settingsService = new SettingsService();
_settingsService.Activate(this);
_settingsEntity = _settingsService.GetSettings();
//Выставить значения
pbLogo.SizeMode = PictureBoxSizeMode.StretchImage;
pbLogo.Image = _settingsEntity.PhotoLogo;
pbProgramBackground.SizeMode = PictureBoxSizeMode.StretchImage;
pbProgramBackground.Image = _settingsEntity.ProgramBackground;
if (this._settingsEntity.PaperType != PaperTypeEnume.Motovay)
{
this.rbtGlanec.Checked = true;
}
else
{
this.rbtMotovay.Checked = true;
}
if (_settingsEntity.PhotoBackground == null)//Если у нас не выбрана текстура, то выставить цвет
{
pbPhotoColor.BackColor = _settingsEntity.BackgroundPhotoColor;
}
else
{
pbPhotoColor.Image = _settingsEntity.PhotoBackground;
pbPhotoColor.SizeMode = PictureBoxSizeMode.StretchImage;
}
lblPageValue.Text = _settingsEntity.PagePrinted.ToString();
}
void ValidateSettings(SettingsEntity settings)
{
if (string.IsNullOrEmpty(settings.DownloadLocal))
{
settings.DownloadLocal = Path.Combine(Environment.CurrentDirectory, @"Data\");
}
}
public void Save(SettingsEntity settings)
{
ValidateSettings(settings);
operations = new SettingsOperations();
operations.Save(settings);
}
/// <summary>
/// This method opens a book when the book's cover image is clicked.
/// </summary>
/// <param name="bookInfo">The book info view model.</param>
private async void OnClickBookCoverImage(BookInfoViewModel bookInfo)
{
if (bookInfo == null)
{
await DisplayAlert("Attention",
"Something went wrong. I can't open this book. Please check does it exist yet?", "Cancel");
throw new ArgumentNullException(nameof(bookInfo));
}
else
{
if (string.IsNullOrEmpty(bookInfo.FilePath))
{
await DisplayAlert("Attention",
"Something went wrong. The path to the book file is empty or it is invalid.", "Cancel");
throw new ArgumentException(nameof(bookInfo.FilePath));
}
else
{
EpubBook epubBook = await EpubReader.EpubReader.ReadBookAsync(bookInfo.FilePath).ConfigureAwait(false);
SettingsEntity settings = this.settingsRepository.GetById(bookInfo.Id);
BookTextPageViewModel page = new BookTextPageViewModel(epubBook, settings, this.settingsRepository)
{
Title = "Go to Main page"
};
Xamarin.Forms.Device.BeginInvokeOnMainThread(() => this.Navigation.PushAsync(page));
}
}
}
/// <summary>
/// Получить настройки принтера по типу фотки
/// </summary>
/// <param name="photoMode"></param>
/// <returns></returns>
private byte[] GetPrinterSettingsByPhotoType(PhotoShotMode photoMode)
{
byte[] numArray;
SettingsEntity settings = this._serviceProvider.GetService <SettingsService>().GetSettings();
if (this._photoMode == PhotoShotMode.Strips4Foto || this._photoMode == PhotoShotMode.Strips3Foto)
{
if (settings.PaperType == PaperTypeEnume.Glynec)
{
numArray = settings.SettingsForPrintGlanectStripsFoto;
}
else
{
numArray = settings.SettingsForPrintMatovoeStripsFoto;
}
}
else
{
if (this._photoMode != PhotoShotMode.Single4Foto && this._photoMode != PhotoShotMode.Single4Foto1Big && this._photoMode != PhotoShotMode.SingleFoto)
{
throw new Exception("Неизвестный режим печати, при задании настроек печати принтеру");
}
numArray = (settings.PaperType != PaperTypeEnume.Glynec ? settings.SettingsForPrintMatovoeSingleFoto : settings.SettingsForPrintGlanecSingleFoto);
}
return(numArray);
}
public void SaveFor(IClassifiable entity, SettingsEntity settings)
{
if (settings != null)
{
settingsRepo.SaveOrUpdateFor(entity, settings);
}
}
/// <inheritdoc/>
public ISettingsEntity Load()
{
var result = new SettingsEntity();
var commandLineArgs = _commandLineService.CommandLineSwitches;
return(result);
}
public async Task InsertOrReplaceAsync(Settings settings)
{
var entity = new SettingsEntity(GetPartitionKey(), GetRowKey());
Mapper.Map(settings, entity);
await _storage.InsertOrReplaceAsync(entity);
}
public EntityTaskSettings(SettingsEntity settings)
{
if (settings == null)
{
throw new Exception("Settings should not be NULL");
}
this.settings = settings;
}
/// <inheritdoc/>
public ISettingsEntity Load()
{
var result = new SettingsEntity();
LoadProjectValues(result);
return(result);
}
public SettingsEntity Get()
{
operations = new SettingsOperations();
SettingsEntity settings = operations.Get();
ValidateSettings(settings);
return(settings);
}
/// <summary>
/// Initialize a new instance of <see cref="BookTextPageViewModel"/> class.
/// </summary>
/// <param name="book">EPUB book.</param>
/// <param name="settings">The settings entity.</param>
/// <param name="settingsRepository">The settings repository.</param>
public BookTextPageViewModel(EpubBook book, SettingsEntity settings, ISettingsRepository settingsRepository)
{
this.settings = settings;
this.settingsRepository = settingsRepository;
IFiler filer = DependencyService.Get <IFiler>();
#region Custom HTML template
HtmlDocument template = new HtmlDocument();
// Hardcode filename
Stream stream = filer.GetResourceFileStreamAsync("index.html").GetAwaiter().GetResult();
template.Load(stream);
var script = "<script>var lastPageNumber = " + this.settings.LastPage + "</script>";
HtmlNode scriptNode = HtmlNode.CreateNode(script);
var head = template.DocumentNode.ChildNodes.FirstOrDefault(c => c.Name == "html")
.ChildNodes.FirstOrDefault(f => f.Name == "head");
head.ChildNodes.Add(scriptNode);
var textContainer = template.DocumentNode.ChildNodes.FirstOrDefault(c => c.Name == "html")
.ChildNodes.FirstOrDefault(f => f.Name == "body")
.ChildNodes.FirstOrDefault(d => d.Id == "page");
foreach (var html in book.Content.Html)
{
HtmlDocument document = new HtmlDocument();
string htmlString = html.Value.Content.Replace(@"\", string.Empty);
document.LoadHtml(htmlString);
var body =
document.DocumentNode.ChildNodes.FirstOrDefault(c => c.Name == "html")
.ChildNodes.FirstOrDefault(f => f.Name == "body");
foreach (var child in body.ChildNodes)
{
textContainer.ChildNodes.Add(child);
}
}
#endregion
string htmlText = template.DocumentNode.OuterHtml.Replace(@"\", string.Empty);
this.webView = new WebView
{
Source = new HtmlWebViewSource {
Html = htmlText
},
VerticalOptions = LayoutOptions.FillAndExpand,
HorizontalOptions = LayoutOptions.FillAndExpand
};
this.webView.Navigating += this.NavigatingHandler;
this.Content = this.webView;
}
public void Save(SettingsEntity settings)
{
Settings.Default.Chrome = settings.Chrome;
Settings.Default.CapInit = settings.CapInit;
Settings.Default.VolQuantity = settings.VolQuantity;
Settings.Default.DownloadLocal = settings.DownloadLocal;
Settings.Default.VolNumber = settings.VolNumber;
Settings.Default.Save();
}
public SettingsModel()
{
Id = Guid.NewGuid();
_entity = new SettingsEntity
{
RowKey = Id.ToString(),
PartitionKey = nameof(SettingsModel),
};
}
/// <inheritdoc/>
public ISettingsEntity Load()
{
var result = new SettingsEntity();
var environmentVariables = _environmentService.EnvironmentVariables;
LoadValues(environmentVariables, result);
return(result);
}
private void BtnSalvar_Click(object sender, EventArgs e)
{
SettingsController controller = new SettingsController();
SettingsEntity settings = new SettingsEntity();
if (cbkChrome.Checked)
{
settings.Chrome = true;
}
if (cbkCap.Checked)
{
if (!string.IsNullOrEmpty(txtCap.Text))
{
settings.CapInit = int.Parse(txtCap.Text);
}
else
{
MessageBox.Show("Por favor digite uma informação", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
settings.CapInit = 1;
}
if (cbkVol.Checked)
{
if (!string.IsNullOrEmpty(txtVol.Text) && !string.IsNullOrEmpty(txtNumeroVol.Text))
{
settings.VolQuantity = int.Parse(txtVol.Text);
settings.VolNumber = int.Parse(txtNumeroVol.Text);
}
else
{
MessageBox.Show("Por favor digite uma informação", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
settings.VolQuantity = 0;
settings.VolNumber = 1;
}
if (cbkLocal.Checked)
{
settings.DownloadLocal = txtPath.Text;
}
controller.Save(settings);
MessageBox.Show("Configuração salva com sucesso!", "Sucesso", MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
}
public async Task <SettingsDto> LoadAsync(string userId)
{
SettingsEntity entity = await FindUserSettings(userId);
if (entity == null)
{
return(new SettingsDto());
}
return(_mapper.Map <SettingsDto>(entity));
}
/// <inheritdoc />
public override ISettings Clone(
ISettings source)
{
Debug.Assert(!(source is null), nameof(source));
var target = new SettingsEntity();
Assign(source, target);
return(target);
}
/// <summary>
/// Insert a new settings entity to database.
/// </summary>
/// <param name="settings">The settings entity.</param>
/// <returns>Returns status code of the operation.</returns>
/// TODO: Make it async
public SQLiteResult Add(SettingsEntity settings)
{
using (var statement = this.database.Prepare("INSERT INTO SETTINGS(BOOKID, LASTPAGE, FONTSIZE) VALUES (?,?,?)"))
{
statement.Bind(1, settings.BookId);
statement.Bind(2, settings.LastPage);
statement.Bind(3, settings.FontSize);
SQLiteResult result = statement.Step();
return(result);
}
}
public long AddNew(string key, string value, string description)
{
using (MyDbContext dbc = new MyDbContext())
{
SettingsEntity entity = new SettingsEntity();
entity.Name = key;
entity.Value = value;
entity.Description = description;
dbc.Settings.Add(entity);
dbc.SaveChanges();
return(entity.Id);
}
}
/// <summary>
/// Сбросить настройки на настройки по умолчанию
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnGetSettingsByDefault_Click(object sender, EventArgs e)
{
_settingsEntity = _settingsService.InitializeEntityByDefault();
_settingsService.SaveSettings(_settingsEntity);
//Выставить значения
pbLogo.SizeMode = PictureBoxSizeMode.StretchImage;
pbLogo.Image = _settingsEntity.PhotoLogo;
pbProgramBackground.SizeMode = PictureBoxSizeMode.StretchImage;
pbProgramBackground.Image = _settingsEntity.ProgramBackground;
pbPhotoColor.BackColor = _settingsEntity.BackgroundPhotoColor;
}
public SettingsEntity Get()
{
SettingsEntity settings = new SettingsEntity
{
Chrome = Settings.Default.Chrome,
CapInit = Settings.Default.CapInit,
VolQuantity = Settings.Default.VolQuantity,
DownloadLocal = Settings.Default.DownloadLocal,
VolNumber = Settings.Default.VolNumber,
MangaSite = Settings.Default.MangaSite,
HentaiSite = Settings.Default.HentaiSite
};
return(settings);
}
public async Task SaveAsync(SettingsDto settings, string userId)
{
SettingsEntity entity = await FindUserSettings(userId);
if (entity == null)
{
entity = _mapper.Map <SettingsEntity>(settings);
entity.UserId = userId;
}
else
{
entity.ShowCompleted = settings.ShowCompleted;
}
await _settingsRepository.SaveAsync(entity);
}
