private string CreateHref(PaperContext ctx, T paper)
{
var paperInfo = PaperSpec.GetSpec <T>();
var paperTemplate = new UriTemplate(paperInfo.Route);
paperTemplate.SetArgsFromGraph(paper);
var uri = paperTemplate.CreateUri();
var targetUri = new Route(uri);
targetUri = targetUri.SetArg(
"f", ctx.PathArgs["f"],
"in", ctx.PathArgs["in"],
"out", ctx.PathArgs["out"]
);
var filter = paper._Get <IFilter>("Filter");
if (filter != null)
{
var map = new FieldMap(filter);
var args = (
from field in map
where field.Value != null
select new[] {
field.Key.ChangeCase(TextCase.CamelCase),
field.Value
}
).SelectMany();
targetUri = targetUri.SetArg(args);
}
return(targetUri.ToString());
}
private void RenderPaper(Entity entity, IPaper paper, PaperContext ctx)
{
//
// Fase 2: Repassando parametros
//
RenderOfBlueprint.SetArgs(paper, ctx.PathArgs);
RenderOfBasics.SetArgs(paper, ctx.PathArgs);
RenderOfPage.SetArgs(paper, ctx);
RenderOfSort.SetArgs(paper, ctx);
RenderOfFilter.SetArgs(paper, ctx);
//
// Fase 3: Consultando dados
//
RenderOfPage.PreCache(paper, ctx);
RenderOfData.CacheData(paper, ctx.Cache);
RenderOfRows.CacheData(paper, ctx.Cache);
RenderOfCards.CacheData(paper, ctx.Cache);
RenderOfPage.PostCache(paper, ctx);
//
// Fase 4: Renderizando entidade
//
RenderOfBlueprint.Render(paper, entity, ctx);
RenderOfBasics.Render(paper, entity, ctx);
RenderOfData.Render(paper, entity, ctx);
RenderOfRows.Render(paper, entity, ctx);
RenderOfPage.Render(paper, entity, ctx);
RenderOfSort.Render(paper, entity, ctx);
RenderOfFilter.Render(paper, entity, ctx);
RenderOfCards.Render(paper, entity, ctx);
}
public static string GetArticleById(string ids)
{
string json = string.Empty;
if (!string.IsNullOrEmpty(ids))
{
var articleIds = ids.Split(',').Select(a => int.Parse(a));
using (var context = new PaperContext())
{
var papers = context.Papers.Where(p => articleIds.Contains(p.PaperID)).OrderByDescending(p => p.PaperID).ToList().Select(p => new
{
p.PaperID,
p.Title,
p.FirstSite,
p.PaperPublishedDate,
p.ReprintCount
});
json = JsonConvert.SerializeObject(papers);
}
}
else
{
json = string.Empty;
}
return(json);
}
/// <summary>
/// Detectando o registro excedente.
/// Se existir, então, temos mais registros no lado do servidor.
/// </summary>
public static void PostCache(IPaper paper, PaperContext ctx)
{
var hasMoreData = false;
var page = ctx.Cache.Get <Page>(CacheKeys.Page);
if (page == null)
{
return;
}
var overSize = page.Limit;
// Voltando o tamanho da página para o original.
page.SetLimitOrSize(page.Limit - 1);
var rows = ctx.Cache.Get <DataWrapperEnumerable>(CacheKeys.Rows);
if (rows != null)
{
hasMoreData = (rows.Count == overSize);
if (hasMoreData)
{
// Reduzindo a quantidade de registros que deve ser lidos
// para provocar o descarte do excedente.
rows.Count--;
}
}
ctx.Cache.Set(CacheKeys.HasMoreData, hasMoreData);
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
string title = this.txtTitle.Text.Trim();
string filePath = this.txtFilePath.Text.Trim();
string summary = this.txtSummary.Text.Trim();
try
{
using (var context = new PaperContext())
{
var entity = new PPTTemplate
{
Title = title,
Path = filePath,
Summary = summary,
AddDate = DateTime.Now
};
context.PPTTemplates.Add(entity);
context.SaveChanges();
this.txtTitle.Text = string.Empty;
this.txtFilePath.Text = string.Empty;
this.txtSummary.Text = string.Empty;
BingGridView1Data();
}
}
catch (DbEntityValidationException ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Renderiza as característica do Paper.
/// </summary>
/// <param name="paper">O Paper com as características de renderização.</param>
/// <param name="entity">A entidade que está sendo renderizada com base no Paper.</param>
/// <param name="ctx">O contexto de renderização.</param>
public static void Render(IPaper paper, Entity entity, PaperContext ctx)
{
entity.AddClass(Class.Blueprint);
AddBlueprint(paper, entity, ctx);
AddLinks(paper, entity, ctx);
}
public static EntityAction ConvertToEntityAction(object graph, PaperContext ctx)
{
var action = graph as EntityAction;
if (action == null)
{
action = new EntityAction();
action.Fields = new FieldCollection();
var fields = graph as IEnumerable <Field>;
if (fields != null)
{
action.Fields.AddRange(fields);
}
else
{
// Cada proprieade do objeto será mapeada como um campo de filtro
foreach (var key in graph._GetPropertyNames())
{
var field = CreateField(graph, key, ctx);
action.Fields.Add(field);
}
}
}
return(action);
}
internal static void SetArgs(IPaper paper, PaperContext ctx)
{
if (!paper._Has("Filter"))
{
return;
}
var filter = paper._Get <IFilter>("Filter");
if (filter == null)
{
if (!paper._CanWrite("Filter"))
{
return;
}
filter = filter._SetNew <IFilter>("Filter");
}
foreach (var arg in ctx.PathArgs)
{
if (filter._Has(arg.Key))
{
filter._Set(arg.Key, arg.Value);
}
}
}
public Link RenderLink(PaperContext ctx)
{
var paper = ctx.Injector.CreateInstance <T>();
setup?.Invoke(paper);
var link = new Link
{
Href = CreateHref(ctx, paper)
};
if (paper._Has <string>("GetTitle"))
{
link.Title = paper._Call <string>("GetTitle");
}
builder?.Invoke(link);
if (title != null)
{
link.Title = title;
}
if (rel != null)
{
link.AddRel(rel);
}
if (link.Rel?.Any() != true)
{
link.AddRel(RelNames.Link);
}
return(link);
}
public void BindPaperCategory(int customerId = 0)
{
using (var context = new PaperContext())
{
var entities = context.PaperCategories.ToList();
if (customerId != 0)
{
entities = entities.Where(a => a.CustomerCategoryID == 0 || a.CustomerCategoryID.Value == customerId).ToList();
}
var items = entities.Select(a => new
{
text = a.CategoryName,
value = a.CategoryID.ToString()
});
this.ddlPaperCategory.Items.Clear();
this.ddlPaperCategory.Items.Add(new ListItem {
Text = "选择类型", Value = "0"
});
items.ForEach(item =>
{
this.ddlPaperCategory.Items.Add(new ListItem {
Text = item.text, Value = item.value
});
});
}
}
private void InitRepeater2(int currentPageIndex = 1)
{
using (var context = new PaperContext())
{
var categories = context.PaperCategories.Select(c => c).OrderByDescending(p => p.CategoryID).ToList();
this.AspNetPager2.RecordCount = categories.Count;
this.Repeater2.DataSource = categories.Skip((currentPageIndex - 1) * this.AspNetPager2.PageSize).Take(this.AspNetPager2.PageSize);
this.Repeater2.DataBind();
}
}
public ActionResult Paper(PaperType type = PaperType.LWK, int nowpageNum = 1)
{
PaperContext context = new PaperContext()
{
Type = type,
NowPage = nowpageNum
};
context.Init();
return(View(context));
}
private void BingGridView1Data(int currentPageIndex = 1)
{
using (var context = new PaperContext())
{
var entities = context.PPTTemplates.OrderByDescending(p => p.ID).Select(p => p).ToList();
this.AspNetPager1.RecordCount = entities.Count();
this.AspNetPager1.CurrentPageIndex = currentPageIndex;
this.GridView1.DataSource = entities.Skip((currentPageIndex - 1) * this.AspNetPager1.PageSize).Take(this.AspNetPager1.PageSize);
this.GridView1.DataBind();
}
}
/// <summary>
/// Forçando a consulta de um item a mais para detectar mais dados
/// disponiveis no lado do servidor
/// </summary>
public static void PreCache(IPaper paper, PaperContext ctx)
{
var page = ctx.Cache.Get <Page>(CacheKeys.Page);
if (page == null)
{
return;
}
page.SetLimitOrSize(page.Limit + 1);
}
/// <summary>
/// Renderizando dados e cabeçalhos básicos
/// </summary>
private static void AddData(IPaper paper, Entity entity, PaperContext ctx, DataWrapper data)
{
foreach (var key in data.EnumerateKeys())
{
var value = data.GetValue(key);
entity.AddProperty(key, value);
var header = data.GetHeader(key);
entity.AddDataHeader(header);
}
}
public ActionResult Laws(PaperType type = PaperType.LWK, int nowpageNum = 1)
{
ViewBag.Title = PaperContext.TypeArrayName[(int)type];
PaperContext context = new PaperContext()
{
Type = type,
NowPage = nowpageNum
};
context.Init();
return(View(context));
}
private void InitComponent()
{
List <string> columns = new List <string>();
columns.Add("FileName");
columns.Add("FilePath");
var table = CommonUtility.CreateMemoryTable(columns);
Session["tempTable"] = table;
DateTime startDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0, 0);
DateTime endDate = startDate.AddDays(1);
using (var context = new ReportContext())
{
var newsCount = context.Articles.Count(a => a.AddDate >= startDate && a.AddDate <= endDate);
this.ltlNewsCount.Text = newsCount.ToString();
var reportsCount = context.Reports.Count();
this.ltlReportsCount.Text = reportsCount.ToString();
var referencesCount = context.ReferenceReports.Count();
this.ltlReferencesCount.Text = referencesCount.ToString();
}
using (var context = new PaperContext())
{
var articlesCount = context.Papers.Count(p => p.AddDate >= startDate && p.AddDate <= endDate);
this.ltlArticlesCount.Text = articlesCount.ToString();
}
this.ltlBarChart.Text = BasicColumnBarChart();
string userId = User.Identity.GetUserId();
if (userId != null)
{
var manager = Context.GetOwinContext().GetUserManager <ApplicationUserManager>();
var user = manager.FindById(userId);
if (user.CanWriteEmail == true)
{
this.send_email_div.Visible = true;
}
else
{
this.send_email_div.Visible = false;
}
}
InitRepeater1();
InitRepeater2();
cblReceiveUser_GetData();
InitRepeater4();
ddlParentGroupID_GetData();
InitRepeater5();
}
public static void Render(IPaper paper, Entity entity, PaperContext ctx)
{
// Os dados foram renderizados anteriormente e estocados no cache
var cards = ctx.Cache.Get <DataWrapperEnumerable>(CacheKeys.Cards);
if (cards == null)
{
return;
}
entity.AddClass(Class.Cards);
AddRowsAndLinks(paper, entity, ctx, cards);
}
private void InitRepeater2()
{
using (var context = new PaperContext())
{
var entities = context.Papers.OrderByDescending(p => p.PaperID).ToList().Select(p => new
{
p.Title,
AddDate = p.AddDate.ToString("yyyy-MM-dd"),
p.Url
}).Take(8);
this.Repeater2.DataSource = entities;
this.Repeater2.DataBind();
}
}
private static void RenderProperties(IPaper paper, Entity entity, PaperContext ctx)
{
if (!paper._Has("GetProperties"))
{
return;
}
var properties = paper._Call("GetProperties");
if (properties == null)
{
return;
}
var dataTable = properties as DataTable;
if (dataTable != null)
{
if (dataTable.Rows.Count > 0)
{
DataRow row = dataTable.Rows[0];
foreach (DataColumn col in dataTable.Columns)
{
var key = Conventions.MakeName(col);
var value = row[col];
entity.AddProperty(key, value);
}
}
return;
}
var dictionary = properties as IDictionary;
if (dictionary != null)
{
foreach (string key in dictionary.Keys)
{
var value = dictionary[key];
entity.AddProperty(key, value);
}
return;
}
foreach (var key in properties._GetPropertyNames())
{
var value = properties._Get(key);
entity.AddProperty(key, value);
}
}
public static void SetArgs(IPaper paper, PaperContext ctx)
{
var sort = paper._Get <Sort>("Sort");
if (sort == null)
{
if (!paper._CanWrite("Sort"))
{
return;
}
sort = paper._SetNew <Sort>("Sort");
}
sort.CopyFromUri(ctx.RequestUri);
}
/// <summary>
/// Renderizando links
/// </summary>
/// <param name="paper">O Paper com as características de renderização.</param>
/// <param name="entity">A entidade que está sendo renderizada com base no Paper.</param>
/// <param name="ctx">O contexto de renderização.</param>
private static void AddLinks(IPaper paper, Entity entity, PaperContext ctx)
{
var indexLink = paper._Call <ILink>("GetIndex");
if (indexLink != null)
{
var link = indexLink.RenderLink(ctx);
if (link != null)
{
link.AddRel(RelNames.Index);
link.Rel.Remove(RelNames.Link);
entity.AddLink(link);
}
}
}
/// <summary>
/// Adiciona as propriedades de blueprint.
/// </summary>
/// <param name="paper">O Paper com as características de renderização.</param>
/// <param name="entity">A entidade que está sendo renderizada com base no Paper.</param>
/// <param name="ctx">O contexto de renderização.</param>
private static void AddBlueprint(IPaper paper, Entity entity, PaperContext ctx)
{
if (!paper._Has("GetBlueprint"))
{
return;
}
var blueprint = paper._Call <Blueprint>("GetBlueprint");
if (blueprint == null)
{
return;
}
entity.AddProperties(blueprint);
}
public static void Render(IPaper paper, Entity entity, PaperContext ctx)
{
// Os dados foram renderizados anteriormente e estocados no cache
var data = ctx.Cache.Get <DataWrapper>(CacheKeys.Data);
if (data == null)
{
return;
}
entity.AddClass(Class.Data);
AddData(paper, entity, ctx, data);
AddDataHeaders(paper, entity, ctx, data);
AddDataLinks(paper, entity, ctx, data);
}
protected void lnkEdit_Command(object sender, CommandEventArgs e)
{
int paperId = 0;
int.TryParse(e.CommandArgument.ToString(), out paperId);
using (var context = new PaperContext())
{
var entity = context.Papers.Find(paperId);
if (entity != null)
{
this.ddlCustomerCategory.SelectedValue = entity.CustomerCategoryID.ToString();
if (entity.CustomerCategoryID != 0)
{
using (var db = new ReportContext())
{
var items = db.Customers.Where(c => c.CategoryID == entity.CustomerCategoryID).Select(c => new
{
text = c.Name,
value = c.ID.ToString()
});
this.ddlCustomer.Items.Clear();
this.ddlCustomer.Items.Add(new ListItem {
Text = "选择分类", Value = "0"
});
items.ForEach(item =>
{
this.ddlCustomer.Items.Add(new ListItem {
Text = item.text, Value = item.value
});
});
}
}
this.ddlCustomer.SelectedValue = entity.CustomerID.ToString();
this.ddlPaperCategory.SelectedValue = entity.CategoryID.ToString();
this.txtTitle.Text = entity.Title;
this.txtPublishedDate.Text = entity.PaperPublishedDate;
this.txtReprintCount.Text = entity.ReprintCount.ToString();
this.txtFirstSite.Text = entity.FirstSite;
this.txtReprintSite.Text = entity.ReprintSite;
this.txtUrl.Text = entity.Url;
this.txtSummary.Text = entity.Summary;
this.hidePaperID.Value = entity.PaperID.ToString();
}
}
}
/// <summary>
/// Renderizando links
/// </summary>
private static void AddDataLinks(IPaper paper, Entity entity, PaperContext ctx, DataWrapper data)
{
var linkRenderers = paper._Call <IEnumerable <ILink> >("GetDataLinks", data.DataSource);
if (linkRenderers != null)
{
foreach (var linkRenderer in linkRenderers)
{
var link = linkRenderer.RenderLink(ctx);
if (link != null)
{
link.AddRel(RelNames.DataLink);
link.Rel.Remove(RelNames.Link);
entity.AddLink(link);
}
}
}
}
protected void lnkPaperCategoryEdit_Command(object sender, CommandEventArgs e)
{
var id = e.CommandArgument.ToString();
using (var context = new PaperContext())
{
int categoryId = int.Parse(id);
var entity = context.PaperCategories.Find(categoryId);
if (entity != null)
{
this.txtPaperCategoryName.Text = entity.CategoryName;
this.ddlCustomerCategoryID.SelectedValue = entity.CustomerCategoryID == null ? "0" : entity.CustomerCategoryID.Value.ToString();
this.txtPaperCategorySummary.Text = entity.CategorySummary;
this.hidePaperCategoryID.Value = entity.CategoryID.ToString();
this.hidePaperCategoryAction.Value = "edit";
}
}
}
private static void AddRowHeaders(IPaper paper, Entity entity, PaperContext ctx, DataWrapperEnumerable rows)
{
// Adicionando os campos autodetectados
//
var keys = rows.EnumerateKeys().ToArray();
foreach (var key in keys)
{
var header = rows.GetHeader(key);
entity.AddRowHeader(header);
}
// Adicionando os campos personalizados
//
var headers = paper._Call <IEnumerable <HeaderInfo> >("GetRowHeaders", rows.DataSource);
if (headers != null)
{
if (!(headers is IList))
{
headers = headers.ToArray();
}
entity.AddRowHeaders(headers);
// Ocultando as colunas não personalizadas
//
entity.ForEachRowHeader((e, h) =>
{
h.Hidden = !headers.Any(x => x.Name.EqualsIgnoreCase(h.Name));
});
}
// Adicionando informação de ordenação
//
var sort = paper._Get <Sort>("Sort");
if (sort != null)
{
entity.ForEachRowHeader((e, h) =>
AddRowHeaderSortInfo(paper, ctx, sort, e, h)
);
}
}
public static void Render(IPaper paper, Entity entity, PaperContext ctx)
{
//
// Valores personalizados
//
if (paper._Has <string>("GetTitle"))
{
var result = paper._Call <string>("GetTitle");
if (result != null)
{
entity.AddTitle(result);
}
}
if (paper._Has <NameCollection>("GetClass"))
{
var result = paper._Call <NameCollection>("GetClass");
if (result != null)
{
entity.AddClass(result);
}
}
if (paper._Has <NameCollection>("GetRel"))
{
var result = paper._Call <NameCollection>("GetRel");
if (result != null)
{
entity.AddRel(result);
}
}
RenderProperties(paper, entity, ctx);
RenderLinks(paper, entity, ctx);
//
// Finalizações
//
if (entity.Title == null)
{
entity.Title = Conventions.MakeTitle(paper.GetType());
}
}
public PaperService(PaperContext paperContext)
{
_context = paperContext;
if (!migrated)
{
this._context.Database.Migrate();
try
{
this._context.Database.ExecuteSqlRaw("CREATE EXTENSION pg_trgm");
}
catch (Exception e) { }
try
{
this._context.Database.ExecuteSqlRaw("CREATE EXTENSION pg_jieba");
}
catch (Exception e) { }
migrated = true;
}
}
