static void Main(string[] args)
{
dynamic json = null;
if (File.Exists(PROP_NAME)) {
Console.WriteLine("read from " + PROP_NAME);
using (FileStream fs = new FileStream(PROP_NAME, FileMode.Open)) {
using (StreamReader sr = new StreamReader(fs)) {
json = DynamicJson.Parse(sr.ReadToEnd());
}
}
}
else {
Console.WriteLine("write to " + PROP_NAME);
json = new DynamicJson();
json.name = "basyura";
// 厳密には別ファイルを作成した後で mv するべきだよなぁ
using (FileStream fs = new FileStream(PROP_NAME, FileMode.Create)) {
using (StreamWriter sw = new StreamWriter(fs)) {
sw.WriteLine(json.ToString());
}
}
}
Console.WriteLine(json.name);
json.name = "hoge";
Console.WriteLine(json.name);
Console.WriteLine(json.ToString());
}
static void Main(string[] args)
{
//①読み込むJSONデータ
var jsonString = @"{""Address"":""Tokyo"",""Age"":32,""Name"":""Doi""}";
//②DynamicJsonクラスのParseメソッドでJSONデータを解析してdynamic型として返す
var obj = DynamicJson.Parse(jsonString);
//③変換したクラスのプロパティ内容を確認
Console.WriteLine("Name:{0}, Address:{1}, Age:{2}", obj.Name, obj.Address, obj.Age);
var friend = new FriendInfo()
{
Name = "Doi",
Address = "Tokyo",
Age = 32
};
//DynamicJsonクラスのSerializeメソッドで.NETオブジェクトをJSONデータに変換
Console.Write(DynamicJson.Serialize(friend));
//DynamicJsonクラスをインスタンス化
dynamic obj2 = new DynamicJson();
//任意のプロパティを設定可能
obj2.Name = "Doi";
obj2.TelNo = "03-xxxx-xxxx";
obj2.MobileTelNo = "090-xxxx-xxxx";
//DynamicJsonオブジェクトのToStringメソッドでJSONデータを出力
Console.WriteLine(obj2.ToString());
PostalCodeSample();
}
public void GetAllData_LocalOnly_ReturnLocal()
{
var c = new Configurator(_libraryFolder.Path, new NavigationIsolator());
dynamic j = new DynamicJson();
j.one = 1;
c.CollectJsonData(j.ToString());
Assert.AreEqual(j, DynamicJson.Parse(c.GetAllData()));
}
/// <summary>
/// Twitter クライアントと基になる JSON オブジェクトを指定し TwitterStreamEventArgs の新しいインスタンスを初期化します。
/// </summary>
/// <param name="client">Twitter クライアント。</param>
/// <param name="json">基になる JSON オブジェクト。</param>
public TwitterStreamEventArgs(TwitterClient client, DynamicJson json)
{
this.json = json;
this.Account = client.Account;
this.Source = new User(client, this.json.source);
this.Target = new User(client, this.json.target);
this.TargetStatus = this.json.target_object() ? new Status(client, this.json.target_object, this.Target) : null;
}
public string ToJson()
{
dynamic root = new DynamicJson();
root.Hide3DSComment = App.ViewModelRoot.Config.NGComment.Hide3DSComment;
root.HideWiiUComment = App.ViewModelRoot.Config.NGComment.HideWiiUComment;
root.NGSharedLevel = App.ViewModelRoot.Config.NGComment.NGSharedLevel;
root.CommentAlpha = CommentAlpha / 100; //%から小数点に
root.DefaultCommentSize = DefaultCommentSize;
return root.ToString();
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = null;
if (jsonObject.All(x => x.Key.ToDynamicCompatableString() != binder.Name))
return false;
var value = jsonObject.Single(x => x.Key.ToDynamicCompatableString() == binder.Name).Value;
if (value.StartsWith("[{\"") && value.EndsWith("}]"))
result = JsonArrayObjects.Parse(value).Select(x => new DynamicJson(x)).ToArray();
else
result = new DynamicJson(value, binder.Name);
return true;
}
public Tweet()
{
try {
FileStream Stream = File.OpenRead("token");
var json = DynamicJson.Parse(Stream);
var token = json.consumerKey;
var secret = json.consumerSecret;
var access = json.accessToken;
var accessSecret = json.accessTokenSecret;
//全て揃っていたら
if(token != "?" && secret != "?" && access != "?" && accessSecret != "?") {
Tokens = CoreTweet.Tokens.Create(token, secret, access, accessSecret);
IsTweetButtonEnable = true;
return;
}
//コンシューマーキーのみだったら
if(token != "" && secret != "" && access == "?") {
Service = OAuth.Authorize(token, secret);
return;
}
Stream.Close();
IsTweetButtonEnable = true;
} catch(FileNotFoundException) {
IsTweetButtonEnable = false;
StreamWriter writer = File.CreateText("token");
writer.AutoFlush = true;
dynamic json = new DynamicJson();
json.consumerKey = "";
json.consumerSecret = "";
json.accessToken = "";
json.accessTokenSecret = "";
writer.WriteLine(json.ToString());
writer.Close();
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (textBox_ID.Text != "" && textBox_Password.Password != "")
{
dynamic json = new DynamicJson();
json.id = textBox_ID.Text;
json.password = textBox_Password.Password;
json.proxy = textBox_Proxy.Text;
File.WriteAllText("data.json", json.ToString(), new UTF8Encoding());
Window_Initialized(null, null);
}
else
{
MessageBox.Show("IDまたはPasswordを正確に入力してください。", "エラー", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
/// <summary>
/// PostのDummy
/// </summary>
/// <param name="json">IDを含んだjson</param>
/// <returns>氏名，プロジェクト，学年，日付を含んだJson</returns>
public static DynamicJson DummyPost(DynamicJson json)
{
DynamicJson data = json;
try
{
}
catch (System.Runtime.Remoting.RemotingTimeoutException ex)
{
Log.WriteLog("TimeOutException", ex);
return null;
}
catch (NullReferenceException ex)
{
Log.WriteLog("NullReferenceException", ex);
return null;
}
return data;
}
public void Save(string cookieName, string cookieValue, Dictionary<string, string> parameters)
{
var collection = HttpContext.Current.Response.Headers;
if (collection.AllKeys.Contains(MobileCookie.COOKIE_NAME))
{
string json = collection[MobileCookie.COOKIE_NAME];
dynamic x1 = DynamicJson.Parse(json);
x1[cookieName] = cookieValue;
string v = x1.ToString();
collection[MobileCookie.COOKIE_NAME] = v;
}
else
{
dynamic x1 = new DynamicJson();
x1[cookieName] = cookieValue;
string v = x1.ToString();
HttpContext.Current.Response.AddHeader(MobileCookie.COOKIE_NAME, v);
}
}
/// <summary>
/// 获取地点分类
/// </summary>
/// <param name="pid">父分类ID，默认为0。</param>
/// <param name="flag">是否返回全部分类，0：只返回本级下的分类，1：返回全部分类，默认为0。</param>
/// <returns></returns>
public dynamic POICategory(string pid = "", bool flag = false)
{
return(DynamicJson.Parse(api.POICategory(pid, flag)));
}
public void OnNext(Session value)
{
if (_onBattle == null)
{
return;
}
try {
var response = value.Response.Body;
string json = Encoding.ASCII.GetString(response, 7, response.Length - 7);
dynamic res = DynamicJson.Parse(json);
if (!res.api_result() || res.api_result != 1)
{
return;
}
var data = res.api_data;
BattleProcess result = new BattleProcess();
result.ZwRawData = json;
int fleetId; // dock deck傻傻分不清楚
if (data.api_dock_id())
{
fleetId = Convert.ToInt32(data.api_dock_id);
}
else
{
fleetId = Convert.ToInt32(data.api_deck_id);
}
result.ZwOurShips = ConvertOurFleet(fleetId, data.api_nowhps, data.api_maxhps, data.api_fParam);
result.ZwEnemyShips = ConvertEnemyFleet(data.api_ship_ke, data.api_ship_lv, data.api_nowhps, data.api_maxhps, data.api_eParam, data.api_eKyouka, data.api_eSlot);
if (data.api_nowhps_combined()) //联合舰队
{
result.ZwOurEscort = ConvertOurFleet(fleetId + 1, data.api_nowhps_combined, data.api_maxhps_combined, data.api_fParam_combined);
}
if (data.api_formation())
{
result.ZwOurFormation = (BattleProcess.Formation)Convert.ToInt32(data.api_formation[0]);
result.ZwEnemyFormation = (BattleProcess.Formation)(int) data.api_formation[1];
result.ZwEncounter = (BattleProcess.EncounterForm)(int) data.api_formation[2];
}
if (data.api_flare_pos()) //夜战
{
var r = new BattleProcess.NightWarInfo(result)
{
ZwRawData = json,
ZwBombard = ConvertBombards(result, data.api_hougeki, value.Request.PathAndQuery.Contains("api_req_combined_battle")),
ZwOurReconnInTouch = (int)data.api_touch_plane[0],
ZwEnemyReconnInTouch = (int)data.api_touch_plane[1]
};
if (r.ZwOurReconnInTouch < 0)
{
r.ZwOurReconnInTouchName = "没有舰载机";
}
else
{
r.ZwOurReconnInTouchName = Helpers.GetEquiptNameWithFallback(r.ZwOurReconnInTouch, "{0} 号侦察机");
}
if (r.ZwEnemyReconnInTouch < 0)
{
r.ZwEnemyReconnInTouchName = "没有舰载机";
}
else
{
r.ZwEnemyReconnInTouchName = Helpers.GetEquiptNameWithFallback(r.ZwEnemyReconnInTouch, "{0} 号侦察机");
}
result.ZwHasNightWar = true;
result.ZwNightWar = r;
result.ZwAirWarfare = _dummyAirwarfare.Clone();
result.ZwAirWarfare._parent = result;
}
if (data.api_stage_flag()) //昼战 航空战/炮击战 共有部分
{
result.ZwAirWarfare = ConvertAirWarfare(result, data.api_kouku);
result.ZwOurReconn = (BattleProcess.ReconnResult)(int) data.api_search[0];
result.ZwEnemyReconn = (BattleProcess.ReconnResult)(int) data.api_search[1];
result.ZwHasNightWar = data.api_midnight_flag > 0;
if (data.api_stage_flag2()) //昼战 航空战
{
result.ZwAirWarfare2 = ConvertAirWarfare(result, data.api_kouku2);
}
else if (data.api_hourai_flag()) //昼战 炮击战
{
if (data.api_opening_atack() && data.api_opening_atack != null)
{
result.ZwOpeningTorpedoAttack = ConvertTorpedoInfo(result, data.api_opening_atack);
}
if (data.api_hougeki1() && data.api_hougeki1 != null)
{
result.ZwBombardRound1 = ConvertBombards(result, data.api_hougeki1, (value.Request.PathAndQuery.Contains("api_req_combined_battle") && !value.Request.PathAndQuery.Contains("water")));
}
if (data.api_hougeki2() && data.api_hougeki2 != null)
{
result.ZwBombardRound2 = ConvertBombards(result, data.api_hougeki2, false);
}
if (data.api_hougeki3() && data.api_hougeki3 != null)
{
result.ZwBombardRound3 = ConvertBombards(result, data.api_hougeki3, (value.Request.PathAndQuery.Contains("api_req_combined_battle") && value.Request.PathAndQuery.Contains("water")));
}
if (data.api_raigeki() && data.api_raigeki != null)
{
result.ZwClosingTorpedoAttack = ConvertTorpedoInfo(result, data.api_raigeki);
}
result.ZwSupportType = (BattleProcess.SupportInfo.Type)(int)(data.api_support_flag() ? data.api_support_flag : 0);
if (data.api_support_info() && (data.api_support_info != null))
{
int supportDeckId = (int)(data.api_support_info.api_support_airatack?.api_deck_id ?? data.api_support_info.api_support_hourai.api_deck_id);
result.ZwSupport = new BattleProcess.SupportInfo()
{
ZwSupportShips = KanColleClient.Current.Homeport.Organization.Fleets[supportDeckId].Ships.Select((x, i) => {
var localShip = DataStore.Store.Current.Ships[x.Id];
return(new BattleProcess.ShipInfo()
{
ZwShipNameType = new ShipNameType(x.Info, i),
ZwId = x.Id,
ZwLv = x.Level,
ZwCurrentHp = x.HP.Current,
ZwMaxHp = x.HP.Maximum,
ZwParameter = new BattleProcess.ShipInfo.ParameterInfo()
{
ZwPower = x.Firepower.Current,
ZwTorpedo = x.Torpedo.Current,
ZwAntiAir = x.AA.Current,
ZwDefense = x.Armer.Current
},
ZwEnhancement = new BattleProcess.ShipInfo.ParameterInfo()
{
ZwAntiAir = localShip.EnhancedAntiAir,
ZwDefense = localShip.EnhancedDefense,
ZwPower = localShip.EnhancedPower,
ZwTorpedo = localShip.EnhancedTorpedo
},
ZwEquipts = x.EquippedSlots.Select(si => new EquiptInfo(si)).ToArray()
});
}).ToArray()
};
if (data.api_support_info.api_support_airatack != null)
{
result.ZwSupport.ZwAttackInfo = ConvertAirWarfare(result, data.api_support_info.api_support_airatack);
}
else if (data.api_support_info.api_support_hourai != null)
{
result.ZwSupport.ZwAttackInfo = CreateSupportAttackInfo(result, data.api_support_info.api_support_hourai);
}
}
}
}
_onBattle(result);
} catch (Exception) { }
}
/// <summary>
/// SetJson
/// </summary>
/// <returns>json</returns>
private string SetJson()
{
dynamic json = new DynamicJson();
json["Name"] = this.Name;
json["Sid"] = this.Sid;
json["LoginTime"] = this.LoginTime;
return json.ToString();
}
/// <summary>
/// 根据GPS坐标获取偏移后的坐标
/// </summary>
/// <param name="coordinate">需要获取偏移坐标的源坐标，经度纬度用逗号分隔。 </param>
/// <returns></returns>
public string GpsToOffset(string coordinate)
{
return(DynamicJson.Parse(api.GpsToOffset(coordinate)));
}
public String toJsonString()
{
try { // just in case :) I don't trust dyamic variables, especially in c#
dynamic d = new DynamicJson ();
if (seed != null) {
d.secret = seed.ToString ();
RippleAddress r = seed.getPublicRippleAddress ();
if (r != null) {
d.Account = r.ToString ();
} else {
// todo debug
}
}
if (encrypted_wallet != null) {
d.encrypted = encrypted_wallet;
if (encryption_type!=null) {
d.encryption_type = encryption_type;
}
} else {
if (seed!=null && seed.ToString()!=null) {
d.secret = seed.ToString();
}
}
if (walletname!=null) {
d.name = walletname;
}
object ao = new object {
};
return d.ToString();
}
catch (Exception e) {
return null;
}
}
private async void InitializeComment() {
Owner.Comment.IsCommentLoading = true;
var list = await Owner.CommentInstance.GetCommentAsync();
VideoData.CommentData.Clear();
if(list != null) {
foreach(var entry in list) {
VideoData.CommentData.Add(new CommentEntryViewModel(entry, Owner));
}
dynamic json = new DynamicJson();
json.array = list;
InvokeScript("CommentViewModel$initialize");
InjectComment(json.ToString());
Owner.Comment.CanComment = true;
Owner.Comment.IsCommentLoading = false;
//投稿者コメントがあったら取得する
if(VideoData.ApiData.HasOwnerThread) {
var ulist = await Owner.CommentInstance.GetUploaderCommentAsync();
dynamic ujson = new DynamicJson();
ujson.array = ulist;
if(ulist != null) {
foreach(var entry in ulist) {
VideoData.CommentData.Add(new CommentEntryViewModel(entry, Owner));
}
InjectUploaderComment(ujson.ToString());
}
}
}
if(!Settings.Instance.CommentVisibility) {
//InvokeScript("AsToggleComment");
} else {
Owner.CommentVisibility = true;
}
}
/// <summary>
/// IDmをJsonにするクラス
/// </summary>
/// <returns>dynamicのまま返す</returns>
private DynamicJson SetJson()
{
dynamic json = new DynamicJson();
json["IDm"] = this.IDm;
return json;
}
void CandidateWebSocketHandler(object sender, WebSocketEventArgs args)
{
WebSocketInfo wi = args.Info;
CandidateInfo info = (CandidateInfo)wi.State;
var msg = DynamicJson.Parse (JSONEncoding.GetString (args.Payload, 0, (int)args.PayloadSize));
string errMsg = string.Empty;
if (info.State == CandidateState.Initialized) {
Console.WriteLine ("[CandidateHandler] Initialized");
long key;
if (!msg.IsDefined ("e") || !msg.IsDefined ("s") || !long.TryParse (msg.e, out key)) {
errMsg = "msg format error";
goto OnError;
}
JoinInfo join_info = null;
lock (waitings_) {
if (!waitings_.TryGetValue (key, out join_info)) {
errMsg = "ignore";
goto OnError;
}
waitings_.Remove (key);
}
join_info.CandidatePeer = wi;
info.Info = join_info;
info.State = CandidateState.IceProcess;
dynamic msg2 = new DynamicJson ();
msg2.r = "ok";
msg2.s = msg.s;
join_info.RequestedPeer.Send (msg2.ToString (), JSONEncoding);
Console.WriteLine ("[CandidateHandler] Relay SDP to join requested peer");
lock(join_info.IceQueue) {
foreach(string ice_cand in join_info.IceQueue) {
msg2 = new DynamicJson();
msg2.ice = ice_cand;
Console.WriteLine("[CandidateHandler] Relay Queued Ice Candidates");
info.Info.RequestedPeer.Send(msg2.ToString(), JSONEncoding);
}
}
return;
}
if (info.State == CandidateState.IceProcess) {
dynamic msg2 = new DynamicJson();
msg2.ice = msg.ice;
Console.WriteLine("[CandidateHandler] Relay Ice Candidates");
info.Info.RequestedPeer.Send(msg2.ToString(), JSONEncoding);
return;
}
OnError:
Console.WriteLine("[CandidateHandler] ERROR: {0}", errMsg);
dynamic retMsg = new DynamicJson ();
retMsg.r = errMsg;
wi.Send (retMsg.ToString (), JSONEncoding);
wi.Close ();
}
public async void ReloadCommentAsync() {
Owner.CommentStatus = "リロード中";
var list = await Owner.CommentInstance.ReloadCommentAsync();
if(list != null) {
foreach(var entry in list) {
int i = 0;
foreach(var comment in VideoData.CommentData) {
//リロードしたコメントをどこに挿入するか
if(int.Parse(comment.Entry.Vpos) > int.Parse(entry.Vpos)) {
VideoData.CommentData.Insert(i, new CommentEntryViewModel(entry, Owner));
break;
}
i++;
}
}
dynamic json = new DynamicJson();
json.array = list;
InjectComment(json.ToString());
Owner.Comment.CanComment = true;
Owner.Comment.IsCommentLoading = false;
}
//成功しようが失敗しようが完了なのさ
Owner.CommentStatus = "リロード完了";
}
void GroupOwnerWebSocketHandler(object sender, WebSocketEventArgs args)
{
WebSocketInfo wi = args.Info;
ALMInfo info = (ALMInfo)wi.State;
var msg = DynamicJson.Parse(JSONEncoding.GetString(args.Payload, 0, (int)args.PayloadSize));
if (info.State == ALMGroupState.Initialized) {
info.GroupID = msg.g;
info.GroupName = msg.IsDefined("n") ? msg.n : info.GroupID;
info.GroupDescription = msg.IsDefined("d") ? msg.d : string.Empty;
dynamic retMsg = new DynamicJson();
lock (groups_) {
if (groups_.ContainsKey(info.GroupID)) {
info.State = ALMGroupState.Error;
retMsg.r = "group_id already exists";
} else {
groups_.Add (info.GroupID, info);
info.State = ALMGroupState.Created;
retMsg.r = "ok";
info.Info = wi;
}
}
wi.Send (retMsg.ToString(), JSONEncoding);
return;
}
if (info.State == ALMGroupState.Created) {
}
}
void JoinWebSocketHandler(object sender, WebSocketEventArgs args)
{
WebSocketInfo wi = args.Info;
JoinInfo info = (JoinInfo)wi.State;
var msg = DynamicJson.Parse(JSONEncoding.GetString(args.Payload, 0, (int)args.PayloadSize));
if (info.State == JoinState.Initialized) {
Console.WriteLine("[JoinHandler] Initialized");
ALMInfo group = null;
lock (groups_) {
if (!groups_.TryGetValue(msg.g, out group)) group = null;
}
if (group == null) {
dynamic retMsg = new DynamicJson();
retMsg.r = "not found";
Console.WriteLine("[JoinHandler] NotFound group");
wi.Send (retMsg.ToString(), JSONEncoding);
} else {
info.RequestedPeer = wi;
dynamic newMemberMsg = new DynamicJson();
long ekey = Interlocked.Increment (ref ephemeral_);
newMemberMsg.m = "new";
newMemberMsg.e = ekey.ToString();
newMemberMsg.s = msg.s;
lock (waitings_) {
waitings_.Add (ekey, info);
}
info.State = JoinState.IceProcess;
Console.WriteLine("[JoinHandler] Relay Offer SDP");
group.Info.Send (newMemberMsg.ToString(), JSONEncoding);
}
return;
}
if (info.State == JoinState.IceProcess) {
if (info.CandidatePeer == null) {
lock (info.IceQueue) {
info.IceQueue.Add(msg.ice);
}
Console.WriteLine("[JoinHandler] Ice Candidates added to queue");
} else {
dynamic msg2 = new DynamicJson();
msg2.ice = msg.ice;
Console.WriteLine("[JoinHandler] Relay Ice Candidates");
string json = msg2.ToString();
info.CandidatePeer.Send(json, JSONEncoding);
}
return;
}
}
protected static string MakeDeleteFileContent(string _description, string filename)
{
dynamic _result = new DynamicJson();
dynamic _file = new DynamicJson();
_result.description = _description;
_result.files = new { };
_result.files[filename] = "null";
return _result.ToString();
}
protected static string MakeEditContent(string _description, string _oldFileName, string _newFileName, string _content)
{
dynamic _result = new DynamicJson();
dynamic _file = new DynamicJson();
_result.description = _description;
_result.files = new { };
_result.files[_oldFileName] = new { filename = _newFileName, content = _content };
return _result.ToString();
}
protected static string MakeCreateContent(string _description, bool _isPublic, IEnumerable<Tuple<string, string>> fileContentCollection)
{
dynamic _result = new DynamicJson();
dynamic _file = new DynamicJson();
_result.description = _description;
_result.@public = _isPublic.ToString().ToLower();
_result.files = new { };
foreach (var fileContent in fileContentCollection)
{
_result.files[fileContent.Item1] = new { filename = fileContent.Item1, content = fileContent.Item2 };
}
return _result.ToString();
}
public void Send(string eventId, string eventData)
{
dynamic e = new DynamicJson();
e.id = eventId;
e.payload = eventData;
//note, if there is no open socket, this isn't going to do anything, and
//that's (currently) fine.
lock(this)
{
foreach (var socket in _allSockets)
{
socket.Send(e.ToString());
}
}
}
/// <summary>
/// 基になる JSON オブジェクトを指定し Relationship の新しいインスタンスを初期化します。
/// </summary>
/// <param name="json">基になる JSON オブジェクト。</param>
public Relationship(DynamicJson json)
: base(json)
{
}
/// <summary>
/// 用户删除自己的位置
/// </summary>
/// <returns></returns>
public dynamic DestoryUserPostion()
{
return(DynamicJson.Parse(api.DestoryUserPostion()));
}
public void GetLibraryData_NoGlobalData_Empty()
{
var first = new Configurator(_libraryFolder.Path);
dynamic j = new DynamicJson();
j.one = 1;
first.CollectJsonData(j.ToString());
Assert.AreEqual("{}", first.GetLibraryData());
}
public void Save()
{
//ロード中に呼び出されたら困る
if(Loading) {
return;
}
//このクラスのタイプを取得
var type = GetType();
//%APPDATA%/SRNicoNico/user.settingsに保存する
var properties = type.GetProperties();
dynamic json = new DynamicJson();
var list = new List<object>();
foreach(var property in properties) {
//ジェネリクスはちょっとややこしい
//型名に<Generic>を追加する
if(property.PropertyType.GenericTypeArguments.Length != 0) {
string generic = "<";
foreach(var types in property.PropertyType.GenericTypeArguments) {
generic += types.Name + ", ";
}
generic = generic.Substring(0, generic.Length - 2) + ">";
string st = property.PropertyType.Name;
st = st.Split('`')[0] + generic;
list.Add(new { Name = property.Name, Type = st, Value = GetNeedValue(st, property) });
} else {
list.Add(new { Name = property.Name, Type = property.PropertyType.Name, Value = GetNeedValue(property.PropertyType.Name, property) });
}
}
json.settings = list;
var s = Format(json.ToString());
var fi = new StreamWriter(Dir + "user.settings");
fi.AutoFlush = true;
fi.Write(s);
fi.Close();
}
public void WhenCollectedNoGlobalDataThenGlobalDataIsEmpty()
{
var first = new Configurator(_libraryFolder.Path);
dynamic j = new DynamicJson();
j.one = 1;
first.CollectJsonData(j.ToString());
Assert.AreEqual(j, DynamicJson.Parse(first.LocalData));
}
/// <summary>
/// 根据地理信息坐标返回实际地址
/// </summary>
/// <param name="coordinate">需要获取实际地址的坐标，经度纬度用逗号分隔。 </param>
/// <returns></returns>
public string GeoToAddress(string coordinate)
{
return(DynamicJson.Parse(api.GeoToAddress(coordinate)));
}
/// <summary>
/// 根据ID获取动态的详情
/// </summary>
/// <param name="id">需要获取的动态ID。</param>
/// <returns></returns>
public dynamic StatusesShow(string id)
{
return(DynamicJson.Parse(api.StatusesShow(id)));
}
/// <summary>
/// 判断地理信息坐标是否是国内坐标
/// </summary>
/// <param name="coordinate">需要判断的坐标，格式：经度,纬度,字符标识|经度,纬度,字符标识。其中经度纬度用逗号分隔，字符标识用于返回结果中的返回值标识。“|”分隔多个坐标。一次最多50个坐标。示例：coordinates=120.035847163,23.1014362572,g1|116.035847163,38.1014362572,g2。 </param>
/// <returns></returns>
public dynamic IsDomestic(string coordinates)
{
return(DynamicJson.Parse(api.IsDomestic(coordinates)));
}
/// <summary>
/// 获取用户的todo列表
/// </summary>
/// <param name="uid">需要查询的用户ID。 </param>
/// <param name="count">单页返回的记录条数，默认为20，最大为50。 </param>
/// <param name="page">返回结果的页码，默认为1。 </param>
/// <param name="baseApp">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。 </param>
/// <returns></returns>
public dynamic UserTodos(string uid, int count = 20, int page = 1, bool baseApp = false)
{
return(DynamicJson.Parse(api.UserTodos(uid, count, page, baseApp)));
}
//リクエストのレスポンスを返す
public async Task <NicoNicoSearchResult> Search(string keyword, SearchType type, string Sort, int page = 1)
{
Owner.Status = "検索中:" + keyword;
Sort = "&sort=" + Sort.Split(':')[0] + "&order=" + Sort.Split(':')[1];
string typestr;
if (type == SearchType.Keyword)
{
typestr = "search";
}
else
{
typestr = "tag";
}
var result = new NicoNicoSearchResult();
try {
var a = await NicoNicoWrapperMain.Session.GetAsync(SearchURL + typestr + "/" + keyword + "?mode=watch" + Sort + "&page=" + page);
//取得したJsonの全体
var json = DynamicJson.Parse(a);
//検索結果総数
if (json.count())
{
result.Total = (int)json.count;
}
else
{
//連打するとエラーになる
Owner.Status = "アクセスしすぎです。1分ほど時間を置いてください。";
return(null);
}
//Jsonからリストを取得、データを格納
if (json.list())
{
foreach (var entry in json.list)
{
var node = new NicoNicoVideoInfoEntry();
node.Cmsid = entry.id;
node.Title = entry.title_short;
node.ViewCounter = (int)entry.view_counter;
node.CommentCounter = (int)entry.num_res;
node.MylistCounter = (int)entry.mylist_counter;
node.ThumbnailUrl = entry.thumbnail_url;
node.Length = entry.length;
node.FirstRetrieve = entry.first_retrieve;
node.FirstRetrieve = node.FirstRetrieve.Replace('-', '/');
result.List.Add(node);
}
}
Owner.Status = "";
return(result);
} catch (RequestTimeout) {
Owner.Status = "検索がタイムアウトしました";
return(null);
}
}
/// <summary>
/// 获取地点照片列表
/// </summary>
/// <param name="poiID">需要查询的POI地点ID。</param>
/// <param name="count">单页返回的记录条数，默认为20，最大为50。</param>
/// <param name="page">返回结果的页码，默认为1。 </param>
/// <param name="sort">排序方式，0：按时间、1：按热门，默认为0，目前只支持0。 </param>
/// <param name="baseApp">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。</param>
/// <returns></returns>
public dynamic POIPhotos(string poiID, int count = 20, int page = 1, bool sort = false, bool baseApp = false)
{
return(DynamicJson.Parse(api.POIPhotos(poiID, count, page, sort, baseApp)));
}
public void WhenCollectedNoLocalDataThenLocalDataIsEmpty()
{
var first = new Configurator(_libraryFolder.Path);
dynamic j = new DynamicJson();
j.library = new DynamicJson();
j.library.librarystuff = "foo";
first.CollectJsonData(j.ToString());
AssertEmpty(first.LocalData);
}
public void Open(string liveid)
{
using (var takeComment = new WebClient() { Encoding = Encoding.UTF8 })
{
Observable.FromEventPattern<DownloadStringCompletedEventHandler, DownloadStringCompletedEventArgs>
(a => takeComment.DownloadStringCompleted += a, a => takeComment.DownloadStringCompleted -= a)
.ObserveOnDispatcher()
.Subscribe(ret =>
{
if (ret.EventArgs.Error != null)
{
this.Close();
}
dynamic ijson = DynamicJson.Parse(ret.EventArgs.Result);
int ccount = ijson.IsDefined("comment_num") ? (int)ijson.comment_num : 0;
Enumerable.Range(1, ccount)
.Where(a => ijson.IsDefined("num_" + a))
.Select(c =>
{
dynamic comment = ijson["num_" + c];
var time = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
.AddMilliseconds(comment.time)
.AddTicks(TimeZoneInfo.Local.BaseUtcOffset.Ticks);
string name = "";
if (comment.auth)
{
name = comment.name;
}
return new CavetubeComment()
{
Name = name,
PostDate = time,
Number = c,
Text = comment.message
};
}).OrderBy(a => a.Number, (a, b) => a - b)
.ForEach(a => this.RaiseOnMessage(new CavetubeClientOnMessageEventArgs(a)));
this.Comments = new List<CavetubeComment>();
this.Connector.OnOpen += e =>
{
dynamic json = new DynamicJson();
json.mode = "join";
json.room = liveid;
this.Send(json.ToString());
};
this.Connector.Open(new Uri("http://ws.cavelis.net:3000/"));
});
takeComment.DownloadStringAsync(new Uri("http://gae.cavelis.net/viewedit/getcomment?stream_name=" + liveid + "&comment_num=1"));
}
}
/// <summary>
/// 获取LBS位置服务内的用户信息
/// </summary>
/// <param name="uid">需要查询的用户ID。</param>
/// <param name="baseApp">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。</param>
/// <returns></returns>
public dynamic UsersShow(string uid, bool baseApp = false)
{
return(DynamicJson.Parse(api.UsersShow(uid, baseApp)));
}
/// <summary>
/// 获取附近照片
/// </summary>
/// <param name="lat">纬度，有效范围：-90.0到+90.0，+表示北纬。 </param>
/// <param name="log">经度，有效范围：-180.0到+180.0，+表示东经。 </param>
/// <param name="range">查询范围半径，默认为500，最大为11132，单位米。 </param>
/// <param name="count">单页返回的记录条数，默认为20，最大为50。 </param>
/// <param name="page">返回结果的页码，默认为1。 </param>
/// <param name="startTime">开始时间，Unix时间戳。 </param>
/// <param name="endTime">结束时间，Unix时间戳。 </param>
/// <param name="sort">排序方式，0：按时间、1：按距离，默认为0。 </param>
/// <param name="offset">传入的经纬度是否是纠偏过，0：没纠偏、1：纠偏过，默认为0。 </param>
/// <returns></returns>
public dynamic NearByPhotos(float lat, float log, int range = 2000, int count = 20, int page = 1, int startTime = 0, int endTime = 0, bool sort = false, bool offset = false)
{
return(DynamicJson.Parse(api.NearByPhotos(lat, log, range, count, page, startTime, endTime, sort, offset)));
}
/// <summary>
/// 获取地点详情
/// </summary>
/// <param name="poiID">需要查询的POI地点ID。</param>
/// <param name="baseApp">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。 </param>
/// <returns></returns>
public dynamic POIShow(string poiID, bool baseApp = false)
{
return(DynamicJson.Parse(api.POIShow(poiID, baseApp)));
}
/// <summary>
/// 获取附近的人
/// </summary>
/// <param name="lat">动态发生的纬度，有效范围：-90.0到+90.0，+表示北纬，默认为0.0。</param>
/// <param name="log">动态发生的经度，有效范围：-180.0到+180.0，+表示东经，默认为0.0。 </param>
/// <param name="count">单页返回的记录条数，最大为50，默认为20。</param>
/// <param name="page">返回结果的页码，默认为1。</param>
/// <param name="range">查询范围半径，默认为2000，最大为11132。</param>
/// <param name="sort">排序方式，0：按时间、1：按距离、2：按社会化关系，默认为2。</param>
/// <param name="filter">用户关系过滤，0：全部、1：只返回陌生人、2：只返回关注人，默认为0。 </param>
/// <param name="gender">性别过滤，0：全部、1：男、2：女，默认为0。</param>
/// <param name="level">用户级别过滤，0：全部、1：普通用户、2：VIP用户、7：达人，默认为0。 </param>
/// <param name="startAge">与参数endbirth一起定义过滤年龄段，数值为年龄大小，默认为空。 </param>
/// <param name="endAge">与参数startbirth一起定义过滤年龄段，数值为年龄大小，默认为空。 </param>
/// <param name="offset">传入的经纬度是否是纠偏过，0：没纠偏、1：纠偏过，默认为0。 </param>
/// <returns></returns>
public dynamic NearByUserList(float lat, float log, int count = 20, int page = 1, int range = 2000, bool sort = false, int filter = 0, int gender = 0, int level = 0, int startAge = 0, int endAge = 0, bool offset = false)
{
return(DynamicJson.Parse(api.NearByUserList(lat, log, count, page, range, sort, filter, gender, level, startAge, endAge, offset)));
}
/// <summary>
/// 按省市查询地点
/// </summary>
/// <param name="keyword">查询的关键词</param>
/// <param name="city">城市代码，默认为全国搜索</param>
/// <param name="category">查询的分类代码，取值范围见：分类代码对应表。</param>
/// <param name="count">单页返回的记录条数，默认为20，最大为50。</param>
/// <param name="page">返回结果的页码，默认为1。 </param>
/// <returns></returns>
public dynamic POISearch(string keyword, string city, string category, int count = 20, int page = 1)
{
return(DynamicJson.Parse(api.POISearch(keyword, city, category, count, page)));
}
/// <summary>
/// 签到同时可以上传一张图片
/// </summary>
/// <param name="poiID">需要签到的POI地点ID。</param>
/// <param name="status">签到时发布的动态内容，内容不超过140个汉字</param>
/// <param name="pic">需要上传的图片，仅支持JPEG、GIF、PNG格式，图片大小小于5M。</param>
/// <param name="isPublic">是否同步到微博，1：是、0：否，默认为0。</param>
/// <returns></returns>
public dynamic CheckIn(string poiID, string status, byte[] pic, bool isPublic = true)
{
return(DynamicJson.Parse(api.CheckIn(poiID, status, pic, isPublic)));
}
/// <summary>
/// 获取附近地点
/// </summary>
/// <param name="lat">纬度，有效范围：-90.0到+90.0，+表示北纬</param>
/// <param name="log">经度，有效范围：-180.0到+180.0，+表示东经。 </param>
/// <param name="range">查询范围半径，默认为2000，最大为10000，单位米。 </param>
/// <param name="q">查询的关键词</param>
/// <param name="category">查询的分类代码，取值范围见：分类代码对应表。 </param>
/// <param name="count">单页返回的记录条数，默认为20，最大为50。 </param>
/// <param name="page">返回结果的页码，默认为1。 </param>
/// <param name="sort">排序方式，0：按权重，默认为0。 </param>
/// <param name="offset">传入的经纬度是否是纠偏过，0：没纠偏、1：纠偏过，默认为0。 </param>
/// <returns></returns>
public dynamic NearByPOIs(float lat, float log, int range = 2000, string q = "", string category = "", int count = 20, int page = 1, bool sort = false, bool offset = false)
{
return(DynamicJson.Parse(api.NearByPOIs(lat, log, range, q, category, count, page, sort, offset)));
}
/// <summary>
/// 添加todo
/// </summary>
/// <param name="poiID">需要添加todo的POI地点ID。</param>
/// <param name="status">添加todo时发布的动态内容，内容不超过140个汉字。</param>
/// <param name="isPublic">是否同步到微博，1：是、0：否，默认为0。 </param>
/// <returns></returns>
public dynamic AddTodo(string poiID, string status, bool isPublic = true)
{
return(DynamicJson.Parse(api.AddTodo(poiID, status, isPublic)));
}
/// <summary>
/// 获取最新20条公共的位置动态
/// </summary>
/// <param name="count">返回的动态数，最大为50，默认为20。 </param>
/// <param name="baseApp">是否只获取当前应用的数据。0为否（所有数据），1为是（仅当前应用），默认为0。 </param>
/// <returns></returns>
public dynamic PublicTimeline(int count = 20, bool baseApp = false)
{
return(DynamicJson.Parse(api.PublicTimeline(count, baseApp)));
}
/// <summary>
/// 提交一个新增的POI点信息
/// </summary>
/// <param name="srcid">来源ID，用户自己设置，用于取回自己提交的POI信息，为2-8位的数字。 </param>
/// <param name="name">POI点的名称，不超过30个字符</param>
/// <param name="address">POI点的地址，不超过60个字符</param>
/// <param name="cityName">POI点的城市中文名称，不超过30个字符</param>
/// <param name="category">POI点的类别中文名称，不超过30个字符</param>
/// <param name="longitude">POI点的经度，2-15个字符</param>
/// <param name="latitude">POI点的维度，2-15个字符</param>
/// <param name="phone">POI点的电话</param>
/// <param name="picUrl">POI点的图片地址</param>
/// <param name="url">POI点的网址</param>
/// <param name="tags">POI点的标签，多个标签之间用逗号分隔，不超过60个字符</param>
/// <param name="description">POI点的介绍，不超过120个字符</param>
/// <param name="intro">POI点的其他特色信息，不超过120个字符，可以以JSON字符串方式提交</param>
/// <param name="traffic">POI点的交通情况描述，不超过120个字符</param>
/// <returns></returns>
public dynamic AddPOI(string srcid, string name, string address, string cityName, string category, string longitude, string latitude, string phone = "", string picUrl = "", string url = "", string tags = "", string description = "", string intro = "", string traffic = "")
{
return(DynamicJson.Parse(api.AddPOI(srcid, name, address, cityName, category, longitude, latitude, phone, picUrl, url, tags, description, intro, traffic)));
}
/// <summary>
/// 添加地点
/// </summary>
/// <param name="title">POI点的名称，不超过30个字符</param>
/// <param name="address">POI点的地址，不超过60个字符</param>
/// <param name="category">POI的类型分类代码，取值范围见：分类代码对应表，默认为500。</param>
/// <param name="lat">纬度，有效范围：-90.0到+90.0，+表示北纬。 </param>
/// <param name="log">经度，有效范围：-180.0到+180.0，+表示东经。 </param>
/// <param name="city">城市代码。 </param>
/// <param name="province">省份代码</param>
/// <param name="country">国家代码</param>
/// <param name="phone">POI点的电话，不超过14个字符</param>
/// <param name="postcode">POI点的邮编</param>
/// <param name="extra">其他</param>
/// <returns></returns>
public dynamic CreatePOI(string title, string address, string category = "500", float lat = 0.0f, float log = 0.0f, string city = "", string province = "", string country = "", string phone = "", string postcode = "", string extra = "")
{
return(DynamicJson.Parse(api.CreatePOI(title, address, category, lat, log, city, province, country, phone, postcode, extra)));
}
/// <summary>
/// 根据移动基站WIFI等数据获取当前位置信息
/// </summary>
/// <param name="json">特殊的JSON参数形式</param>
/// <returns></returns>
public dynamic GetLocationByMobileStation(string json)
{
return(DynamicJson.Parse(api.GetLocationByMobileStation(json)));
}
/// <summary>
/// 添加照片
/// </summary>
/// <param name="poiID">需要添加照片的POI地点ID。 </param>
/// <param name="status">签到时发布的动态内容，，内容不超过140个汉字</param>
/// <param name="pic">需要上传的图片，仅支持JPEG、GIF、PNG格式，图片大小小于5M。 </param>
/// <param name="isPublic">是否同步到微博，1：是、0：否，默认为0。 </param>
/// <returns></returns>
public dynamic AddPhoto(string poiID, string status, byte[] pic, bool isPublic = true)
{
return(DynamicJson.Parse(api.AddPhoto(poiID, status, pic, isPublic)));
}
/// <summary>
/// 根据起点与终点数据查询公交乘坐路线信息
/// </summary>
/// <param name="beginPID">查询起点POI的ID，与begin_coordinate参数必选其一，begin_pid优先。</param>
/// <param name="beginCoordinate">查询起点的坐标，经度纬度用逗号分隔，与begin_pid参数必选其一，begin_pid优先。 </param>
/// <param name="endPID">查询终点POI的ID，与end_coordinate参数必选其一，end_pid优先。 </param>
/// <param name="endCoordinate">查询终点的坐标，经度纬度用逗号分隔，与end_pid参数必选其一，end_pid优先。 </param>
/// <param name="type">查询类型，0：速度优先、1：费用优先、2：距离优先，默认值为0。 </param>
/// <returns></returns>
public dynamic BusRouteLine(string beginPID = "", string beginCoordinate = "", string endPID = "", string endCoordinate = "", int type = 0)
{
return(DynamicJson.Parse(api.BusRouteLine(beginPID, beginCoordinate, endPID, endCoordinate, type)));
}
/// <summary>
/// 用户添加自己的位置
/// </summary>
/// <param name="lat">纬度，有效范围：-90.0到+90.0，+表示北纬。 </param>
/// <param name="log">经度，有效范围：-180.0到+180.0，+表示东经。 </param>
/// <returns></returns>
public dynamic CreateUserPosition(float lat, float log)
{
return(DynamicJson.Parse(api.CreateUserPosition(lat, log)));
}
/// <summary>
/// 根据关键词查询公交站点信息
/// </summary>
/// <param name="q">查询的关键词</param>
/// <param name="city">城市代码，默认为北京搜索。 </param>
/// <param name="page">返回结果的页码，默认为1，最大为40。 </param>
/// <param name="count">单页返回的记录条数，默认为10，最大为50。 </param>
/// <returns></returns>
public dynamic BusStation(string q, string city = "", int page = 1, int count = 10)
{
return(DynamicJson.Parse(api.BusStation(q, city, page, count)));
}
/// <summary>
/// 获取当前登录用户与其好友的位置动态
/// </summary>
/// <param name="sinceID">若指定此参数，则返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0。 </param>
/// <param name="maxID">若指定此参数，则返回ID小于或等于max_id的微博，默认为0。 </param>
/// <param name="count">单页返回的记录条数，默认为50。 </param>
/// <param name="page">返回结果的页码，默认为1。 </param>
/// <param name="type">关系过滤，0：仅返回关注的，1：返回好友的，默认为0</param>
/// <returns></returns>
public dynamic FriendsTimeline(string sinceID = "0", string maxID = "0", int count = 20, int page = 1, int type = 0)
{
return(DynamicJson.Parse(api.FriendsTimeline(sinceID, maxID, count, page, type)));
}
/// <summary>
/// 生成一张静态的地图图片
/// </summary>
/// <param name="center">中心点坐标，经度纬度用逗号分隔，与城市代码两者必选其一，中心点坐标优先。 </param>
/// <param name="city">城市代码，与中心点坐标两者必选其一，中心点坐标优先</param>
/// <param name="coordinates">地图上标点的坐标串，经度纬度用逗号分隔，多个坐标间用“|”分隔，最多不超过10个。示例：coordinates=120.0358,23.1014|116.0358,38.1014。 </param>
/// <param name="names">地图上标点的名称串，多个名称用逗号分隔，最多不超过10个，数量必须与coordinates参数一致，超出的无效。</param>
/// <param name="offsetX">x轴偏移方向，东移为正，西移为负，偏移单位为1/4图片宽度，示例：offset_x=1，地图向右移动1/4。 </param>
/// <param name="offsetY">y轴偏移方向，北移为正，南移为负，偏移单位为1/4图片高度，示例：offset_y=1，地图向上移动1/4。 </param>
/// <param name="font">字体格式，参数形式为：”字体,字体风格,字号,字体颜色,背景颜色,是否有背景“，其中是否有背景（0：无，1：有），示例：font=宋体,1,20,0XFF0C0C,0XFFFF00,1，默认值为“宋体,1,20,0XFF0CC0,0XFFFFE0,1”，字号最大不超过72号字，如果coordinates参数不存在则font参数无效。 </param>
/// <param name="lines">在地图中画一条线，参数形式为：“线的颜色,线的宽度,线的拐点坐标”，拐点坐标经度纬度用逗号分隔，多个坐标间用“|”分隔，最多不超过10个，示例：lines=0XFF0000,2,116.32,39.96|116.12,39.96，取值范围为：线的宽度0-50。 </param>
/// <param name="polygons">在地图中画一个多边形，参数形式为：“边框颜色,边框宽度,填充颜色,填充透明度,多边形的拐点坐标”，拐点坐标经度纬度用逗号分隔，多个坐标间用“|”分隔，最多不超过10个，示例：polygons=0XFF0000,1,0XFF0000,50,116.32,39.96|116.12,39.96|116.32,39.86，取值范围：边框宽度0-50，默认为1、填充透明度0（透明）-100（不透明），默认为50。 </param>
/// <param name="size">生成的地图大小，格式为宽×高，最大值为800，默认为240，示例：size=480×360。 </param>
/// <param name="format">生成的地图的图片格式，支持png、jpg等格式，参数全部为小写，默认为png。 </param>
/// <param name="zoom">地图焦距等级，取值范围为1-17，默认为自适应大小。</param>
/// <param name="scale">是否显示比例尺，true：是，false：否。 </param>
/// <param name="traffic">是否需要叠加实际交通地图，true：是，false：否。 </param>
/// <returns></returns>
public dynamic GetMapImage(string center = "", string city = "", string coordinates = "", string names = null, string offsetX = "", string offsetY = "", string font = "", string lines = "", string polygons = "", string size = "240×240", string format = "png", string zoom = "", bool scale = false, bool traffic = false)
{
return(DynamicJson.Parse(api.GetMapImage(center, city, coordinates, names, offsetX, offsetY, font, lines, polygons, size, format, zoom, scale, traffic)));
}
public override void LoadFromResponse( string apiname, dynamic data ) {
switch ( apiname ) {
case "api_req_kousyou/createitem": //不足パラメータの追加
case "api_req_kousyou/getship":
data.api_locked = 0;
data.api_level = 0;
break;
case "api_get_member/ship3": //存在しないアイテムを追加…すると処理に不都合があるので、ID:1で我慢 一瞬だし無問題（？）
{
int id = data;
data = new DynamicJson();
data.api_id = id;
data.api_slotitem_id = 1;
data.api_locked = 0;
data.api_level = 0;
} break;
default:
break;
}
base.LoadFromResponse( apiname, (object)data );
}
/// <summary>
/// 根据IP地址返回地理信息坐标
/// </summary>
/// <param name="ip">需要获取坐标的IP地址，最多不超过10个。</param>
/// <returns></returns>
public dynamic IPtoGeo(string[] ips)
{
return(DynamicJson.Parse(api.IPtoGeo(ips)));
}
private void Initialize(string videoUrl)
{
IsActive = true;
Task.Run(() => {
Mylist = new VideoMylistViewModel(this);
VideoData = new VideoData();
Status = "動画情報取得中";
//動画情報取得
VideoData.ApiData = NicoNicoWatchApi.GetWatchApiData(videoUrl);
//ロードに失敗したら
if(VideoData.ApiData == null) {
LoadFailed = true;
IsActive = false;
Status = "動画の読み込みに失敗しました。";
return;
}
//有料動画なら
if(VideoData.ApiData.IsPaidVideo) {
App.ViewModelRoot.Messenger.Raise(new TransitionMessage(typeof(PaidVideoDialog), this, TransitionMode.Modal));
return;
}
DispatcherHelper.UIDispatcher.BeginInvoke(new Action(() => {
while(VideoFlash == null) {
Thread.Sleep(1);
}
if(VideoData.ApiData.Cmsid.Contains("nm")) {
VideoData.VideoType = NicoNicoVideoType.SWF;
WebBrowser.Source = new Uri(GetNMPlayerPath());
} else if(VideoData.ApiData.GetFlv.VideoUrl.StartsWith("rtmp")) {
VideoData.VideoType = NicoNicoVideoType.RTMP;
WebBrowser.Source = new Uri(GetRTMPPlayerPath());
} else {
if(VideoData.ApiData.MovieType == "flv") {
VideoData.VideoType = NicoNicoVideoType.FLV;
} else {
VideoData.VideoType = NicoNicoVideoType.MP4;
}
WebBrowser.Source = new Uri(GetPlayerPath());
}
}));
IsActive = false;
Time = new VideoTime();
//動画時間
Time.VideoTimeString = NicoNicoUtil.ConvertTime(VideoData.ApiData.Length);
if(VideoData.ApiData.GetFlv.IsPremium && !VideoData.ApiData.GetFlv.VideoUrl.StartsWith("rtmp")) {
Task.Run(() => {
Status = "ストーリーボード取得中";
NicoNicoStoryBoard sb = new NicoNicoStoryBoard(VideoData.ApiData.GetFlv.VideoUrl);
VideoData.StoryBoardData = sb.GetStoryBoardData();
Status = "ストーリーボード取得完了";
});
}
NicoNicoComment comment = new NicoNicoComment(VideoData.ApiData.GetFlv, this);
List<NicoNicoCommentEntry> list = comment.GetComment();
if(list != null) {
foreach(NicoNicoCommentEntry entry in list) {
VideoData.CommentData.Add(new CommentEntryViewModel(entry));
}
dynamic json = new DynamicJson();
json.array = list;
DispatcherHelper.UIDispatcher.BeginInvoke(new Action(() => InjectComment(json.ToString())));
}
if(!Properties.Settings.Default.CommentVisibility) {
DispatcherHelper.UIDispatcher.BeginInvoke(new Action(() => InvokeScript("JsToggleComment")));
} else {
CommentVisibility = true;
}
//App.ViewModelRoot.StatusBar.Status = "動画取得完了";
});
}
/// <summary>
/// 根据实际地址返回地理信息坐标
/// </summary>
/// <param name="address">需要获取坐标的实际地址</param>
/// <returns></returns>
public dynamic AddressToGeo(string address)
{
return(DynamicJson.Parse(api.AddressToGeo(address)));
}
