protected override void ConfigureImpl(FileInfo configFile)
{
base.ConfigureImpl(configFile);
this.ServerAddress = this.Configuration.ServerAddress;
this.ServerPort = this.Configuration.ServerPort;
this.Storage = this.Host.ModuleManager.GetModule<StorageModule>(this.Configuration.StorageName);
}
public IList<IList<String>> OutputFlowInterfacesAsTable(IEnumerable<FlowInterfaceInfo> input, StorageModule storage, String param, IDictionary<String, String> args)
{
return Make.Sequence(Make.Array("ID", "Summary", "Remarks", "Input", "Output", "Flags"))
.Concat(input.OfType<FlowInterfaceInfo>().Select(i => Make.Array(
i.Id,
i.Summary ?? "(null)",
i.Remarks ?? "(null)",
i.InputType != null
? i.InputType.ToString().Substring(i.InputType.Namespace.Length + 1)
: "-",
i.OutputType.ToString().Substring(i.OutputType.Namespace.Length + 1),
String.Concat(
i.RequiresInput ? "<tt title='Requires input'>I</tt>" : "<tt title='Not requires input'>-</tt>",
i.ReturnsAdditionalData ? "<tt title='Returns additional data'>A</tt>" : "<tt title='Not returns additional data'>-</tt>"
)
)))
.ToArray();
}
public Object ApplyStoredRequest(StorageModule storage, String param, IDictionary<String, String> args)
{
return this.Host.StoredRequestManager.Execute(param, args);
}
public Object AbortServant(StorageModule storage, String param, IDictionary<String, String> args)
{
this.Host.ModuleManager.GetModule<ServantModule>(args["key"]).Abort();
return null;
}
public Object RemoveModuleObject(StorageModule storage, String param, IDictionary<String, String> args)
{
this.Host.ModuleManager[args["domain"]].Remove(args["key"], Type.GetType(args["type"]));
return null;
}
public IEnumerable<Tag> GetTags(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable tags = storage.GetTags(
args.GetValueOrDefault("accountId"),
args.ContainsKey("timestamp") ? DateTime.Parse(args["timestamp"]) : default(Nullable<DateTime>),
args.GetValueOrDefault("category"),
args.GetValueOrDefault("subId"),
args.GetValueOrDefault("name"),
args.GetValueOrDefault("value")
).OrderByDescending(t => t).AsQueryable();
if (args.ContainsKey("query"))
{
tags = tags.Execute(args["query"]);
}
return tags.Cast<Tag>();
}
public IEnumerable<FlowInterfaceInfo> GetSelfFlowInterfaces(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable interfaces = this.Host.ModuleManager.GetModules(
args.ContainsKey("domain") ? args["domain"] : null,
args.ContainsKey("key") ? args["key"] : null,
args.ContainsKey("type")
? args["type"].Do(k =>
{
switch (k)
{
case "input":
return typeof(InputFlowModule);
case "filter":
return typeof(FilterFlowModule);
case "output":
return typeof(OutputFlowModule);
default:
return Type.GetType(k);
}
})
: typeof(FlowModule)
)
.OfType<FlowModule>()
.Single()
.GetFlowInterfaces()
.Select(p => p.Key)
.OrderBy(i => i.Id)
.ThenBy(i => i.InputType != null ? i.InputType.FullName : String.Empty)
.ThenBy(i => i.OutputType.FullName)
.AsQueryable();
if (args.ContainsKey("query"))
{
interfaces = interfaces.Execute(args["query"]);
}
return interfaces.Cast<FlowInterfaceInfo>();
}
public IEnumerable<Relation> GetRelations(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable relations = storage.GetRelations(
args.GetValueOrDefault("accountId"),
args.GetValueOrDefault("name"),
args.GetValueOrDefault("relatingAccountId")
).OrderByDescending(r => r).AsQueryable();
if (args.ContainsKey("query"))
{
relations = relations.Execute(args["query"]);
}
return relations.Cast<Relation>();
}
public String OutputHumanReadableTableXml(IEnumerable<StorageObject> input, StorageModule storage, String param, IDictionary<String, String> args)
{
return this.OutputHumanReadableTable(input, storage, param, args)
.XmlObjectSerializeToString<IList<IList<String>>, DataContractSerializer>();
}
/// <summary>
/// フロー インターフェイスを呼び出します。
/// </summary>
/// <param name="module">呼び出しに用いるモジュール オブジェクト。</param>
/// <param name="input">フィルタ処理の入力として与えるストレージ オブジェクトのシーケンス。</param>
/// <param name="storage">ストレージ オブジェクトの入出力先として使用するストレージ。</param>
/// <param name="parameter">処理のパラメータ。</param>
/// <param name="arguments">処理の引数のリスト。</param>
/// <param name="additionalData">処理の結果に付随して返される追加のデータ。このパラメータは初期化せずに渡されます。</param>
/// <returns>処理の結果。</returns>
public Object Invoke(
FlowModule module,
Object input,
StorageModule storage,
String parameter,
IDictionary<String, String> arguments,
out IDictionary<String, Object> additionalData
)
{
IDictionary<String, Object> data = null;
Object result = ((IEnumerable<Object>) Make.Array<Object>(storage, parameter, arguments))
.If(
a => this.RequiresInput,
a => Make.Sequence(input).Concat(a)
)
.If(
a => this.ReturnsAdditionalData,
a => a.Concat(Make.Sequence<Object>(new Dictionary<String, Object>()))
)
.Do(a => this._method.Invoke(module, a.ToArray())
.Let(_ => data = this.ReturnsAdditionalData
? (IDictionary<String, Object>) a.Last()
: null
)
);
storage.TryUpdate();
additionalData = data;
return result;
}
private void AsyncAnalyzeFollowing(JObject jobj, StorageModule storage)
{
Lambda.New(() => storage.Execute(s =>
{
jobj.Value<JArray>("friends")
.Values<String>()
.Select(i => this._storage.NewAccount(this.Realm, Create.Table("Id", i)))
.ForEach(a => this._self.Relate("Follow", a));
s.TryUpdate();
this.Log.Info("Following data was updated with User Streams.");
})).BeginInvoke(ar => ar.GetAsyncDelegate<Action>().EndInvoke(ar), null);
}
private Account AnalyzeUser(JObject jobj, StorageModule storage, DateTime timestamp)
{
Account account = storage.NewAccount(this.Realm, Create.Table("Id", jobj.Value<String>("id")));
if (!account.Activities.Any(a => a.Category == "Id"))
{
account.Act(timestamp, "Id", jobj.Value<String>("id"));
}
UpdateActivity(account, timestamp, "CreatedAt", jobj.Value<String>("created_at"));
UpdateActivity(account, timestamp, "Description", jobj.Value<String>("description"));
UpdateActivity(account, timestamp, "FollowersCount", jobj.Value<String>("followers_count"));
UpdateActivity(account, timestamp, "FollowingCount", jobj.Value<String>("friends_count"));
UpdateActivity(account, timestamp, "Location", jobj.Value<String>("location"));
UpdateActivity(account, timestamp, "Name", jobj.Value<String>("name"));
UpdateActivity(account, timestamp, "ProfileBackgroundColor", jobj.Value<String>("profile_background_color"));
UpdateActivity(account, timestamp, "ProfileBackgroundImage", jobj.Value<String>("profile_background_image_url"));
UpdateActivity(account, timestamp, "ProfileBackgroundTile", jobj.Value<Boolean>("profile_background_tile").ToString());
UpdateActivity(account, timestamp, "ProfileImage", jobj.Value<String>("profile_image_url"));
UpdateActivity(account, timestamp, "ProfileLinkColor", jobj.Value<String>("profile_link_color"));
UpdateActivity(account, timestamp, "ProfileSidebarBorderColor", jobj.Value<String>("profile_sidebar_border_color"));
UpdateActivity(account, timestamp, "ProfileSidebarFillColor", jobj.Value<String>("profile_sidebar_fill_color"));
UpdateActivity(account, timestamp, "ProfileTextColor", jobj.Value<String>("profile_text_color"));
UpdateActivity(account, timestamp, "Restricted", jobj.Value<Boolean>("protected").ToString());
UpdateActivity(account, timestamp, "ScreenName", jobj.Value<String>("screen_name"));
UpdateActivity(account, timestamp, "StatusesCount", jobj.Value<String>("statuses_count"));
UpdateActivity(account, timestamp, "TimeZone", jobj.Value<String>("time_zone"));
UpdateActivity(account, timestamp, "Uri", jobj.Value<String>("url"));
return account;
}
private Activity AnalyzeStatus(JObject jobj, StorageModule storage)
{
DateTime timestamp = ParseTimestamp(jobj.Value<String>("created_at"));
Account account = this.AnalyzeUser(jobj.Value<JObject>("user"), storage, timestamp);
Activity post = account.Act(
timestamp,
"Post",
jobj.Value<String>("id"),
jobj.Value<String>("source").If(s => s.Contains("</a>"), s =>
s.Remove(s.Length - 4 /* "</a>" */).Substring(s.IndexOf('>') + 1)
),
jobj.Value<String>("text"),
null
);
if (jobj.Value<Boolean>("favorited"))
{
this._self.Mark("Favorite", post);
}
// TODO: reply
return post;
}
private Mark AnalyzeRetweet(JObject jobj, StorageModule storage)
{
DateTime timestamp = ParseTimestamp(jobj.Value<String>("created_at"));
return AnalyzeUser(jobj.Value<JObject>("source"), storage, timestamp)
.Mark("Retweet", AnalyzeStatus(jobj.Value<JObject>("target_object"), storage));
}
private Relation AnalyzeFollow(JObject jobj, StorageModule storage)
{
DateTime timestamp = ParseTimestamp(jobj.Value<String>("created_at"));
return AnalyzeUser(jobj.Value<JObject>("source"), storage, timestamp)
.Relate("Follow", AnalyzeUser(jobj.Value<JObject>("target"), storage, timestamp));
}
public IEnumerable<Activity> GetPosts(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable posts = storage.GetActivities(
args.GetValueOrDefault("accountId"),
args.ContainsKey("timestamp") ? DateTime.Parse(args["timestamp"]) : default(Nullable<DateTime>),
"Post",
args.GetValueOrDefault("subId"),
args.GetValueOrDefault("userAgent"),
args.ContainsKey("value")
? args["value"].If(String.IsNullOrEmpty, s => DBNull.Value, s => (Object) s)
: null,
args.ContainsKey("data")
? args["data"].If(String.IsNullOrEmpty, s => DBNull.Value, s => (Object) s.Base64Decode().ToArray())
: null
).OrderByDescending(p => p).AsQueryable();
if (args.ContainsKey("query"))
{
posts = posts.Execute(args["query"]);
}
return posts.Cast<Activity>();
}
public IEnumerable<Reference> GetReferences(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable references = storage.GetReferences(
args.GetValueOrDefault("accountId"),
args.ContainsKey("timestamp") ? DateTime.Parse(args["timestamp"]) : default(Nullable<DateTime>),
args.GetValueOrDefault("category"),
args.GetValueOrDefault("subId"),
args.GetValueOrDefault("name"),
args.GetValueOrDefault("referringAccountId"),
args.ContainsKey("referringTimestamp") ? DateTime.Parse(args["referringTimestamp"]) : default(Nullable<DateTime>),
args.GetValueOrDefault("referringCategory"),
args.GetValueOrDefault("referringSubId")
).OrderByDescending(r => r).AsQueryable();
if (args.ContainsKey("query"))
{
references = references.Execute(args["query"]);
}
return references.Cast<Reference>();
}
public String OutputTwitterXmlFormat(IEnumerable<StorageObject> input, StorageModule storage, String param, IDictionary<String, String> args)
{
Account subject = this.GetAccount(storage, args.GetValueOrDefault("subject", this.Configuration.ResolveValue<String>("defaultSubject")));
String type = input.All(o => o is Activity && ((Activity) o).Category == "Post")
? "statuses"
: input.All(o => o is Account)
? "users"
: "objects";
return new StringWriter().Let(
// TODO: Support <users> output: check input elements' type?
new XDocument(
new XDeclaration("1.0", "utf-16", "yes"),
new XElement(type,
new XAttribute("type", "array"),
new XAttribute("metatweet-version", ThisAssembly.EntireCommitId),
input.OrderByDescending(o => o).Select(o => o is Account
? this.OutputUser((Account) o, subject, true)
: o is Activity && ((Activity) o).Category == "Post"
? this.OutputStatus((Activity) o, subject, true)
: new XElement("not-supported-object")
)
)
).Save).ToString();
}
public IEnumerable<RequestTask> GetRequestTasks(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable tasks = this.Host.RequestManager
.OrderByDescending(t => t.Id)
.AsQueryable();
if (args.ContainsKey("query"))
{
tasks = tasks.Execute(args["query"]);
}
return tasks.Cast<RequestTask>();
}
private Account GetAccount(StorageModule storage, String screenName)
{
return storage.GetActivities(
default(String),
null,
"ScreenName",
null,
null,
screenName,
null
)
.AsEnumerable()
.OrderByDescending(a => a)
.FirstOrDefault()
.Account;
}
public IEnumerable<StoredRequest> GetStoredRequests(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable storedRequests = this.Host.StoredRequestManager.StoredRequests.Values
.OrderBy(s => s.Name)
.AsQueryable();
if (args.ContainsKey("query"))
{
storedRequests = storedRequests.Execute(args["query"]);
}
return storedRequests.Cast<StoredRequest>();
}
public IList<IList<String>> OutputHumanReadableTable(IEnumerable<StorageObject> input, StorageModule storage, String param, IDictionary<String, String> args)
{
Account subject = this.GetAccount(storage, args.GetValueOrDefault("subject", this.Configuration.ResolveValue<String>("defaultSubject")));
switch (input.First().ObjectType)
{
case StorageObjectTypes.Account:
return Make.Sequence(Make.Array("ID", "ScreenName", "Name", "Location", "Bio", "Web", "F/F", "Flags"))
.Concat(input.OfType<Account>().Select(a => Make.Array(
String.Format(
"<span title='{1}'>{0}</span>",
a["Id"].Value,
a.AccountId
),
a["ScreenName"].TryGetValue(),
a["Name"].TryGetValue(),
a["Location"].TryGetValue(),
a["Description"].TryGetValue(),
a["Uri"].TryGetValue(),
a["FollowingCount"].TryGetValue() + " / " + a["FollowersCount"].TryGetValue(),
String.Concat(
a["Restricted"].TryGetValue() == "True" ? "<tt title='Protected'>P</tt>" : "<tt title='Not protected'>-</tt>",
a.IsRelated("Follow", subject) ? "<tt title='Following'>F</tt>" : "<tt title='Not following'>-</tt>",
a.IsRelating("Follow", subject) ? "<tt title='Follower'>f</tt>" : "<tt title='Not follower'>-</tt>"
)
)))
.ToArray();
case StorageObjectTypes.Activity:
return Make.Sequence(Make.Array("User", "Timestamp", "Category", "Text", "Flags", "Source"))
.Concat(input.OfType<Activity>().Select(a => Make.Array(
String.Format(
"<span title='{1} ({2})'>{0}</span>",
a.Account["ScreenName"].TryGetValue(),
a.Account["Name"].TryGetValue(),
a.Account["Id"].Value
),
a.Timestamp.ToLocalTime().ToString("yy/MM/dd HH:mm:ss"),
a.Category,
a.Value,
String.Concat(
a.Account["Restricted"].TryGetValue() == "True" ? "<tt title='Protected'>P</tt>" : "<tt title='Not protected'>-</tt>",
a.Account.IsRelated("Follow", subject) ? "<tt title='Following'>F</tt>" : "<tt title='Not following'>-</tt>",
a.Account.IsRelating("Follow", subject) ? "<tt title='Follower'>f</tt>" : "<tt title='Not follower'>-</tt>",
a.IsMarked("Favorite", subject) ? "<tt title='Favorited'>S</tt>" : "<tt title='Not favorited'>-</tt>"
),
a.UserAgent
)))
.ToArray();
case StorageObjectTypes.Annotation:
return Make.Sequence(Make.Array("ID", "ScreenName", "UserName", "Name", "Value"))
.Concat(input.OfType<Annotation>().Select(a => Make.Array(
String.Format(
"<span title='{1}'>{0}</span>",
a.Account["Id"].Value,
a.AccountId
),
a.Account["ScreenName"].TryGetValue(),
a.Account["Name"].TryGetValue(),
a.Name,
a.Value
)))
.ToArray();
case StorageObjectTypes.Relation:
return Make.Sequence(Make.Array("ID", "ScreenName", "UserName", "Name", "RelID", "RelScreenName", "RelName"))
.Concat(input.OfType<Relation>().Select(r => Make.Array(
String.Format(
"<span title='{1}'>{0}</span>",
r.Account["Id"].Value,
r.AccountId
),
r.Account["ScreenName"].TryGetValue(),
r.Account["Name"].TryGetValue(),
r.Name,
String.Format(
"<span title='{1}'>{0}</span>",
r.RelatingAccount["Id"].Value,
r.RelatingAccountId
),
r.RelatingAccount["ScreenName"].TryGetValue(),
r.RelatingAccount["Name"].TryGetValue()
)))
.ToArray();
case StorageObjectTypes.Mark:
return Make.Sequence(Make.Array("ID", "ScreenName", "UserName", "Name", "MarkUser", "MarkTimestamp", "MarkCategory", "MarkText"))
.Concat(input.OfType<Mark>().Select(m => Make.Array(
String.Format(
"<span title='{1}'>{0}</span>",
m.Account["Id"].Value,
m.AccountId
),
m.Account["ScreenName"].TryGetValue(),
m.Account["Name"].TryGetValue(),
m.Name,
String.Format(
"<span title='{1} ({2})'>{0}</span>",
m.MarkingActivity.Account["ScreenName"].TryGetValue(),
m.MarkingActivity.Account["Name"].TryGetValue(),
m.MarkingActivity.Account["Id"].Value
),
m.MarkingActivity.Timestamp.ToLocalTime().ToString("yy/MM/dd HH:mm:ss"),
m.MarkingActivity.Category,
m.MarkingActivity.Value
)))
.ToArray();
case StorageObjectTypes.Reference:
return Make.Sequence(Make.Array("User", "Timestamp", "Category", "Name", "Text", "RefUser", "RefTimestamp", "RefCategory", "RefText"))
.Concat(input.OfType<Reference>().Select(r => Make.Array(
String.Format(
"<span title='{1} ({2})'>{0}</span>",
r.Activity.Account["ScreenName"].TryGetValue(),
r.Activity.Account["Name"].TryGetValue(),
r.Activity.Account["Id"].Value
),
r.Activity.Timestamp.ToLocalTime().ToString("yy/MM/dd HH:mm:ss"),
r.Activity.Category,
r.Activity.Value,
r.Name,
String.Format(
"<span title='{1} ({2})'>{0}</span>",
r.ReferringActivity.Account["ScreenName"].TryGetValue(),
r.ReferringActivity.Account["Name"].TryGetValue(),
r.ReferringActivity.Account["Id"].Value
),
r.ReferringActivity.Timestamp.ToLocalTime().ToString("yy/MM/dd HH:mm:ss"),
r.ReferringActivity.Category,
r.ReferringActivity.Value
)))
.ToArray();
default: // case StorageObjectTypes.Tag:
return Make.Sequence(Make.Array("User", "Timestamp", "Category", "Text", "Name", "Value"))
.Concat(input.OfType<Tag>().Select(t => Make.Array(
String.Format(
"<span title='{1} ({2})'>{0}</span>",
t.Activity.Account["ScreenName"].TryGetValue(),
t.Activity.Account["Name"].TryGetValue(),
t.Activity.Account["Id"].Value
),
t.Activity.Timestamp.ToLocalTime().ToString("yy/MM/dd HH:mm:ss"),
t.Activity.Category,
t.Activity.Value,
t.Name,
t.Value
)))
.ToArray();
}
}
public IEnumerable<StorageObject> NullInput(StorageModule storage, String param, IDictionary<String, String> args)
{
return Enumerable.Empty<StorageObject>();
}
public IEnumerable<Annotation> GetAnnotations(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable annotations = storage.GetAnnotations(
args.GetValueOrDefault("accountId"),
args.GetValueOrDefault("name"),
args.GetValueOrDefault("value")
).OrderByDescending(a => a).AsQueryable();
if (args.ContainsKey("query"))
{
annotations = annotations.Execute(args["query"]);
}
return annotations.Cast<Annotation>();
}
public Object UnloadModuleAssembly(StorageModule storage, String param, IDictionary<String, String> args)
{
this.Host.ModuleManager.Unload(args["domain"]);
return null;
}
public IEnumerable<Mark> GetMarks(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable marks = storage.GetMarks(
args.GetValueOrDefault("accountId"),
args.GetValueOrDefault("name"),
args.GetValueOrDefault("markingAccountId"),
args.ContainsKey("markingTimestamp") ? DateTime.Parse(args["markingTimestamp"]) : default(Nullable<DateTime>),
args.GetValueOrDefault("markingCategory"),
args.GetValueOrDefault("markingSubId")
).OrderByDescending(m => m).AsQueryable();
if (args.ContainsKey("query"))
{
marks = marks.Execute(args["query"]);
}
return marks.Cast<Mark>();
}
public Object AddModuleObject(StorageModule storage, String param, IDictionary<String, String> args)
{
this.Host.ModuleManager[args["domain"]].Add(args["key"], args["type"], new List<String>());
return null;
}
public IEnumerable<ModuleDomain> GetModuleDomains(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable domains = this.Host.ModuleManager.ModuleDomains.AsQueryable();
if (args.ContainsKey("query"))
{
domains = domains.Execute(args["query"]);
}
return domains.Cast<ModuleDomain>();
}
public IEnumerable<Account> GetAccounts(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable activities = storage.GetAccounts(
args.GetValueOrDefault("accountId"),
args.GetValueOrDefault("realm"),
args.GetValueOrDefault("seedString")
).OrderByDescending(a => a).AsQueryable();
if (args.ContainsKey("query"))
{
activities = activities.Execute(args["query"]);
}
return activities.Cast<Account>();
}
public IEnumerable<IModule> GetModuleObjects(StorageModule storage, String param, IDictionary<String, String> args)
{
IQueryable modules = this.Host.ModuleManager.GetModules(
args.ContainsKey("domain") ? args["domain"] : null,
args.ContainsKey("key") ? args["key"] : null,
args.ContainsKey("type")
? args["type"].Do(k =>
{
switch (k)
{
case "flow":
return typeof(FlowModule);
case "input":
return typeof(InputFlowModule);
case "filter":
return typeof(FilterFlowModule);
case "output":
return typeof(OutputFlowModule);
case "servant":
return typeof(ServantModule);
case "storage":
return typeof(StorageModule);
default:
return Type.GetType(k);
}
})
: typeof(IModule)
)
.OrderBy(m => m.Name)
.ThenBy(m => m.GetType().FullName)
.AsQueryable();
if (args.ContainsKey("query"))
{
modules = modules.Execute(args["query"]);
}
return modules.Cast<IModule>();
}
