/// <summary>
/// Inserts a handler at the first position of this pipeline.
/// </summary>
/// <returns></returns>
public Pipeline AddFirst(string name, IChannelHandler handler)
{
CheckDuplicateName(name);
var item = new HandlerItem(name, handler);
_name2Item.Add(name, item);
_handlers.AddFirst(item);
//handler.HandlerAdded(_ctx);
return this;
}
private void SearchStuff()
{
string txt = tbEntry.Text;
lbResults.Invoke(new MethodInvoker(lbResults.Items.Clear));
if (txt == "")
{
return;
}
HandlerItem[] items = masterHandler.GetResultsFor(txt);
lbResults.Invoke(new MethodInvoker(delegate()
{
lbResults.Items.AddRange(items);
}));
if (lbResults.Items.Count > 0)
{
if (selItem != null)
{
for (int i = 0; i < lbResults.Items.Count; i++)
{
HandlerItem item = (HandlerItem)lbResults.Items[i];
if (item.Equals(selItem))
{
lbResults.Invoke(new MethodInvoker(delegate()
{
lbResults.SelectedIndex = i;
tbDisplay_SetText();
}));
return;
}
}
}
lbResults.Invoke(new MethodInvoker(delegate()
{
lbResults.SelectedIndex = 0;
tbDisplay_SetText();
SaveSelectedItem();
}));
}
}
/// <summary>
/// Inserts a handler before an existing handler of this pipeline.
/// </summary>
/// <param name="baseName"></param>
/// <param name="name"></param>
/// <param name="handler"></param>
/// <returns></returns>
public Pipeline AddBefore(string baseName, string name, IChannelHandler handler)
{
HandlerItem baseItem;
if (!_name2Item.TryGetValue(baseName, out baseItem))
{
throw new ArgumentException("The requested base item does not exist in this pipeline.");
}
CheckDuplicateName(name);
var item = new HandlerItem(name, handler);
_name2Item.Add(name, item);
var nBase = new LinkedListNode <HandlerItem>(baseItem);
var nNew = new LinkedListNode <HandlerItem>(item);
_handlers.AddBefore(nBase, nNew);
//handler.HandlerAdded(_ctx);
return(this);
}
public void Register <Service>(Service serviceImpl)
{
Type type = typeof(Service);
if (!type.IsInterface)
{
throw new XRPCException($"{type} not interface!");
}
if (!serviceImpl.GetType().IsClass)
{
throw new XRPCException($"{serviceImpl} not the implementer!");
}
foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
string url = $"/{type.Name}/{method.Name}";
var item = new HandlerItem {
Controller = serviceImpl, Url = url, Handler = new ClientActionHandler(method)
};
item.Parameters = (from a in method.GetParameters() select a.ParameterType).ToArray();
mHandlers[url] = item;
}
}
public override void Update()
{
base.Update();
const String CrawlerPath = @"D:\ip1\travox.com\www\crawler\documents\";
const String ViewerPath = @"C:\ip1\travox.com\www\mos\mos_demo\report_viewer\";
SecretaryEvent Period = SecretaryEvent.Unknow;
SQLCollection param = new SQLCollection("@id", DbType.Int32, base.State.CompanyID);
List<HandlerItem> EventEmail = new List<HandlerItem>();
foreach (DataRow Row in new DB("travox_system").GetTable(base.GetResource("secretary_report.sql"), param).Rows)
{
ParameterDate SystemDate;
switch(Row["period"].ToString())
{
case "Daily": Period = SecretaryEvent.Daily; break;
case "Weekly": Period = SecretaryEvent.Weekly; break;
case "Monthly": Period = SecretaryEvent.Monthly; break;
}
SystemDate.From = DateTime.Now.Date;
SystemDate.To = DateTime.Now.Date;
DateTime DateEndMonth = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1).AddMonths(1).AddDays(-1);
String PeriodDate = "";
String OutputEmailType = Row["output_email"].ToString().Trim();
String OutputPrinter = Row["output_printer"].ToString().Trim();
if (Period == SecretaryEvent.Monthly && DateTime.Now.Date == DateEndMonth)
{
PeriodDate = SystemDate.From.ToString("yyyy");
SystemDate.From = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
SystemDate.To = DateEndMonth;
}
else if (Period == SecretaryEvent.Weekly && DateTime.Now.DayOfWeek == DayOfWeek.Sunday)
{
PeriodDate = SystemDate.From.ToString("MM-yyyy");
SystemDate.From = SystemDate.From.AddDays(-7);
}
else if (Period == SecretaryEvent.Daily)
{
PeriodDate = SystemDate.From.ToString("dd-MM-yyyy");
}
else
{
Period = SecretaryEvent.Unknow;
}
if ((!MBOS.Null(OutputEmailType) || MBOS.Bool(OutputPrinter)) && Period != SecretaryEvent.Unknow)
{
RequestBuilder ReportViewer = new RequestBuilder((!App.DebugMode) ? "mos.travox.com/mos_v2/report_viewer/default.aspx" : "localhost:8026/Default.aspx");
ReportViewer.By = RequestBuilder.Method.POST;
ReportViewer.SetCookie("ASP.NET_SessionId", "xxxxxxxxxxxxxxxxxxxxxxxx");
ReportViewer.SetCookie("COMPANY_ACCESS", base.State.CompanyCode);
ReportViewer.SetCookie("ID", "-4");
ReportViewer.SetCookie("Code", "TX");
ReportViewer.SetCookie("Name", "Travox Sentinel");
//ReportViewer.POST("ItemType", JSON.Serialize<ItemType>(new ItemType { ExportType = OutputEmailType }));
//ReportViewer.POST("Report", JSON.Serialize<ItemReport>(new ItemReport { Name = Row["report_key"].ToString(), Filename = Row["report_key"].ToString() + ".rpt" }));
ReportViewer.AddBody("period_begin", SystemDate.From.ToString("dd-MM-yyyy"));
ReportViewer.AddBody("period_end", SystemDate.To.ToString("dd-MM-yyyy"));
param.Add("@s_id", DbType.Int32, Row["secretary_id"].ToString());
param.Add("@name", DbType.String, Row["report_name"].ToString());
param.Add("@email", DbType.String, Row["email"].ToString());
param.Add("@code", DbType.String, base.State.CompanyCode);
param.Add("@file", DbType.String, null);
String[] ArgsString = { Row["period"].ToString(), PeriodDate, Row["report_name"].ToString() };
HandlerItem Item = new HandlerItem();
Item.Subject = String.Format("Secretary({0} {1}) Report of \"{2}\"", ArgsString);
Item.OnEmail = !MBOS.Null(OutputEmailType);
Item.OnPrinter = MBOS.Bool(OutputPrinter);
Item.Mail = Row["email"].ToString();
Item.Ajax = ReportViewer;
EventEmail.Add(Item);
}
}
foreach (HandlerItem Item in EventEmail)
{
//CallbackException data = JSON.Deserialize<CallbackException>(XHR.Connect(Item.Ajax));
CallbackException data = new CallbackException();
String getItems = Regex.Match(data.getItems, @"[\\|/]Temp[\\|/](?<path>.*)").Groups["path"].Value;
String AttachFile = null;
if (!data.onError)
{
String FolderName = Path.GetDirectoryName(CrawlerPath + getItems) + "\\";
String FileName = Path.GetFileName(getItems);
if (!App.DebugMode)
{
if (Directory.Exists(FolderName)) Directory.CreateDirectory(FolderName);
File.Copy(ViewerPath + data.getItems, FolderName + FileName);
File.Delete(ViewerPath + data.getItems);
AttachFile = FolderName + FileName;
}
else
{
AttachFile = @"D:\Travox Mid-Back\TravoxViewer\TravoxViewer\Temp\" + getItems;
}
}
if (Item.OnEmail)
{
DB db = new DB("travox_system");
NameValueCollection MailParam = new NameValueCollection();
TypeMAIL ReportSecretary = new TypeMAIL("*****@*****.**", Item.Subject, false);
ReportSecretary.Add(Item.Mail);
ReportSecretary.Body(base.GetResource("MailTemplate.html"));
String SQL = db.Execute("INSERT INTO crawler.secretary_email (secretary_id, company_code, report_name, email) VALUES (@s_id, @code, @name, @email)", param);
MailParam.Add("message_email", data.exMessage);
MailParam.Add("print_date", DateTime.Now.Date.ToString("dd-MM-yyyy"));
if (!data.onError && data.exTitle != "ManualException")
{
ReportSecretary.Attach(AttachFile);
param["@file"].DefaultValue = getItems;
}
else
{
param["@file"].DefaultValue = data.exMessage;
}
param.Add("@e_id", DbType.Int32, SQL);
db.Execute("UPDATE crawler.secretary_email SET filename=@file WHERE email_id=@e_id", param);
ReportSecretary.DataSource(MailParam);
if (!ReportSecretary.Sending())
{
param["@file"].DefaultValue = ReportSecretary.ErrorMessage;
db.Execute("UPDATE crawler.secretary_email SET filename=@file WHERE email_id=@e_id", param);
}
db.Apply();
}
if (Item.OnPrinter)
{
}
}
param = null;
EventEmail = null;
Console.WriteLine("{0} Updated", base.State.DatabaseName);
}
private void SaveSelectedItem()
{
selItem = (HandlerItem)lbResults.SelectedItem;
}
/// <summary>
/// Inserts a handler before an existing handler of this pipeline.
/// </summary>
/// <param name="baseName"></param>
/// <param name="name"></param>
/// <param name="handler"></param>
/// <returns></returns>
public Pipeline AddBefore(string baseName, string name, IChannelHandler handler)
{
HandlerItem baseItem;
if (!_name2Item.TryGetValue(baseName, out baseItem))
{
throw new ArgumentException("The requested base item does not exist in this pipeline.");
}
CheckDuplicateName(name);
var item = new HandlerItem(name, handler);
_name2Item.Add(name, item);
var nBase = new LinkedListNode<HandlerItem>(baseItem);
var nNew = new LinkedListNode<HandlerItem>(item);
_handlers.AddBefore(nBase, nNew);
//handler.HandlerAdded(_ctx);
return this;
}
/// <summary>
/// Adds a new projection handler to the cache.
/// </summary>
/// <typeparam name="TDomainModelRoot">The domain model used with the projection handler.</typeparam>
/// <param name="handler">An instance of the projection handler (this will be stored).</param>
public void RegisterProjectionHandler <TDomainModelRoot, TDomainModelProjectionHandler>()
where TDomainModelRoot : class, IDomainModelRoot, new()
where TDomainModelProjectionHandler : class, IDomainModelProjectionHandler <TDomainModelRoot>
{
// ignore the registration if we've already seen this one
var domainType = typeof(TDomainModelRoot);
if (handlers.ContainsKey(domainType))
{
return;
}
// verify config exists for this domain model
if (!configService.ContainsConfiguration <TDomainModelRoot>())
{
throw new Exception($"No configuration registered for domain model {typeof(TDomainModelRoot).Name}");
}
var projectionConfig = configService.GetConfiguration <TDomainModelRoot>().Projection;
// create an instance of the handler
var handler = Activator.CreateInstance(typeof(TDomainModelProjectionHandler), projectionConfig) as IDomainModelProjectionHandler <TDomainModelRoot>;
var handlerType = handler.GetType();
logger.LogDebug($"Registering projection handler {handlerType.Name} for domain model {domainType.Name}");
// prepare to store the handler
var item = new HandlerItem {
Handler = handler
};
// validate and catalog the projection methods
var methods = handlerType.GetMethods();
foreach (var method in methods)
{
var snapshotAttr = (SnapshotProjectionAttribute)Attribute.GetCustomAttribute(method, typeof(SnapshotProjectionAttribute));
var eventAttrs = (DomainEventProjectionAttribute[])Attribute.GetCustomAttributes(method, typeof(DomainEventProjectionAttribute));
if (snapshotAttr != null || eventAttrs.Length > 0)
{
if (method.GetParameters().Length != 0)
{
throw new ArgumentException($"Projection handler {method.Name} is invalid: methods must not have arguments");
}
if (!typeof(Task).IsAssignableFrom(method.ReturnType) ||
(AsyncStateMachineAttribute)method.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) == null)
{
throw new ArgumentException($"Projection handler {method.Name} is invalid: methods must return an async Task");
}
// store snapshot handler
if (snapshotAttr != null)
{
item.SnapshotMethods.Add(method);
logger.LogDebug($" Caching projection method {method.Name} for snapshot updates");
}
// store domain event handlers
foreach (var domainEvent in eventAttrs)
{
if (item.EventMethods.Any(e => e.DomainEvent.Equals(domainEvent.DomainEvent) && e.ProjectionMethod.Equals(method)))
{
throw new ArgumentException($"Projection handler method {method.Name} declares domain event {domainEvent.DomainEvent.Name} more than once");
}
var tuple = (domainEvent.DomainEvent, method);
item.EventMethods.Add(tuple);
logger.LogDebug($" Caching projection method {method.Name} for domain event {domainEvent.DomainEvent.Name}");
}
}
}
if (item.EventMethods.Count == 0 && item.SnapshotMethods.Count == 0)
{
throw new ArgumentException($"No projection handler methods found for domain event handler {handlerType.Name}");
}
// store the handler
handlers.Add(domainType, item);
}
