public override async Task <bool> CheckCompletion()
{
try
{
Log.Debug("Ethereum: check refund event");
var wsUri = Web3BlockchainApi.WsUriByChain(Eth.Chain);
var web3 = new Web3(new WebSocketClient(wsUri));
var refundEventHandler = web3.Eth
.GetEvent <RefundedEventDTO>(Eth.SwapContractAddress);
var filter = refundEventHandler
.CreateFilterInput <byte[]>(Swap.SecretHash);
var events = await refundEventHandler
.GetAllChanges(filter)
.ConfigureAwait(false);
if (events.Count > 0)
{
Log.Debug("Refund event received");
CompleteHandler?.Invoke(this);
return(true);
}
}
catch (Exception e)
{
Log.Error(e, "Ethereum refund control task error");
}
CancelHandler?.Invoke(this);
return(true);
}
public void AddComments(String id, String text, CompleteHandler handler)
{
if (m_netEngine == null)
m_netEngine = new DoubanNetEngine();
RestRequest request = new RestRequest();
request.Method = WebMethod.Post;
request.Path = String.Format("shuo/v2/statuses/{0}/comments", id);
request.AddParameter("text", text);
request.AddParameter("source", DoubanSdkData.AppKey);
m_netEngine.SendRequest(request, (DoubanSdkResponse response) =>
{
if (response.errCode == DoubanSdkErrCode.SUCCESS)
{
DoubanEventArgs args = new DoubanEventArgs();
args.errorCode = DoubanSdkErrCode.SUCCESS;
args.specificCode = response.specificCode;
handler(args);
}
else
{
DoubanEventArgs args = new DoubanEventArgs();
args.errorCode = response.errCode;
args.specificCode = response.specificCode;
handler(args);
}
});
}
public void OnSearch()
{
DateTime start;
DateTime end;
if (GetDateTimeFromText(out start) && GetEndDateTimeFromText(out end))
{
Reservation res = new Reservation("You", start, end);
List <RoomItems> requiredItems = new List <RoomItems>();
if (beamer.activeSelf)
{
requiredItems.Add(RoomItems.BEAMER);
}
if (Computers.activeSelf)
{
requiredItems.Add(RoomItems.COMPUTERS);
}
if (Smartboard.activeSelf)
{
requiredItems.Add(RoomItems.SMARTBOARD);
}
CompleteHandler.GetInstance().SetReservation(res, roomSize, building, floor - 1, requiredItems);
SceneManager.LoadScene("Nathalie's scene (sceme 4 the results page)");
}
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.C))
{
Room fake = new Room();
fake.building = Building.EPYDROST;
fake.floor = 2;
fake.inspectorReservations = new List <Reservation>();
fake.reservations = new Dictionary <DateTime, List <Reservation> >();
fake.size = RoomSize.LABSIZE;
fake.roomNumber = "G2.30";
DateTime t = DateTime.Today;
DateTime st = new DateTime(t.Year, t.Month, t.Day, 10, 30, 0);
DateTime end = st.AddHours(1);
Reservation res = new Reservation(st, end);
CompleteHandler.GetInstance().CreateReservation(res, fake);
//for(int i = 0; i < 2; ++i)
//{
// Reservation some = new Reservation(st, end);
// CompleteHandler.GetInstance().CreateReservation(some, fake);
//}
Init();
}
}
public virtual void ProcessPacketStream(SocketStateObject state, PacketIdentifier packetId, DataStream packetStream)
{
if (Handler.Contains(packetId) || CompleteHandler.Contains(packetId))
{
GamePacket packet;
if (!PacketsRegistry.TryGetPacket(packetId, out packet))
{
packet = new BasePacket();
}
packet.Deserialize(packetStream);
var args = Handler.HandlePacket(packetId, packet);
if (args == null || !args.Cancel)
{
if (args == null)
{
Send(state, packetId.PacketId, packetStream.Reset());
}
else
{
Send(state, packetId, packet);
}
CompleteHandler.HandlePacket(packetId, packet);
}
}
else
{
Send(state, packetId.PacketId, packetStream);
}
}
private static void OnLoadComplete(object sender, AssetsProxy assetsproxy, object data)
{
_completeHandler?.Invoke(null);
_completeHandler = null;
_progressHandler = null;
_errorHandler = null;
}
private static void OnLoadError(object sender, string msg, object data)
{
_errorHandler?.Invoke(null, msg, data);
_completeHandler = null;
_progressHandler = null;
_errorHandler = null;
}
public void Start(CompleteHandler completeHandler, BatchProgressHandler progressHandler, ErrorHandler errorHandler,
BatchSingleCompleteHandler singleCompleteHandler)
{
if (this._started)
{
return;
}
this._started = true;
this.completeHandler = completeHandler;
this.progressHandler = progressHandler;
this.errorHandler = errorHandler;
this.singleCompleteHandler = singleCompleteHandler;
this.numLoaded = 0;
int count = this._loaders.Count;
if (count > 0)
{
for (int i = 0; i < count; i++)
{
IBatchLoader loader = this._loaders[i];
loader.Load(this.OnLoadComplete, this.OnLoadProgress, this.OnLoadError, this._useWWW, this._fromCache, this._sync);
}
}
else
{
this.completeHandler?.Invoke(this);
}
}
void OnDestroy()
{
if (_fileDic != null)
{
_fileDic.Clear();
_fileDic = null;
}
if (_modifiedList != null)
{
_modifiedList.Clear();
_modifiedList = null;
}
if (_fileWWW != null)
{
_fileWWW.Dispose();
_fileWWW = null;
}
if (_md5WWW != null)
{
_md5WWW.Dispose();
_md5WWW = null;
}
if (completeHandler != null)
{
completeHandler = null;
}
if (progressUpdateHandler != null)
{
progressUpdateHandler = null;
}
}
public static void Preload(string id, string[] players, string[] neutrals, string[] structures,
CompleteHandler completeHandler, ProgressHandler progressHandler, ErrorHandler errorHandler)
{
_completeHandler = completeHandler;
_progressHandler = progressHandler;
_errorHandler = errorHandler;
_lb = new LoadBatch();
_lb.Add(new AssetsLoader("scene/" + ModelFactory.GetBattleData(id).model + "_navmesh"));
_lb.Add(new AssetsLoader("model/range_circle", "range_circle"));
_lb.Add(new AssetsLoader("model/route_point", "route_point"));
_lb.Add(new AssetsLoader("model/route_point_drag", "route_point_drag"));
int count = players.Length;
for (int i = 0; i < count; i++)
{
CollectModels(players[i], _lb);
}
count = neutrals.Length;
for (int i = 0; i < count; i++)
{
CollectModels(neutrals[i], _lb);
}
count = structures.Length;
for (int i = 0; i < count; i++)
{
CollectModels(structures[i], _lb);
}
_lb.data = id;
_lb.Start(OnPreloadComplete, OnPreloadProgress, OnPreloadError, OnSingleLoadComplete);
}
public void BeginSceneActivation(CompleteHandler callback, object param = null)
{
if (this._asyncOperation != null)
{
SyncTask.Create(this.HandleSceneActivation(callback, param));
}
}
public FileDownloader(String downloadUrl, CompleteHandler c, ProgressHandler p)
{
completed = c;
progress = p;
string tempPath = System.IO.Path.GetTempPath();
destinationFile = tempPath + downloadUrl.Remove(downloadUrl.LastIndexOf('/'));
destinationFile = tempPath + @"\ManokInstaller.exe";
File.Delete(destinationFile);
url = downloadUrl;
WorkerReportsProgress = true;
WorkerSupportsCancellation = true;
WorkerReportsProgress = true;
DoWork += FileDownloader_DoWork;
RunWorkerCompleted +=
new System.ComponentModel.RunWorkerCompletedEventHandler(this.DownloadComplete);
ProgressChanged +=
new ProgressChangedEventHandler(this.ProgressUpdate);
RunWorkerAsync();
}
public void hide(float delay = 0, CompleteHandler completeHandler = null)
{
this.completeHandler = completeHandler;
enabled = true;
startTime = Time.time + delay;
targetPosition = new Vector3(transform.localPosition.x, -3, transform.localPosition.z);
}
private static IEnumerator HandleUnloadScene(AsyncOperation ao, CompleteHandler completeCallback, object param)
{
while (!ao.isDone)
{
yield return(0);
}
completeCallback?.Invoke(null, param);
}
public static CompleteHandler GetInstance()
{
if (instance == null)
{
instance = new CompleteHandler();
}
return(instance);
}
public ScheduleEntry(float[] times, ScheduleHandler scheduleCallback, CompleteHandler completCallback, object param = null)
{
this._times = times;
this.scheduleCallback = scheduleCallback;
this._completCallback = completCallback;
this._timeStamp = 0f;
this._param = param;
}
public void FadeOut(CompleteHandler callback)
{
DOTween.To((t) => this.saturationAmount = t, this.saturationAmount, 1f, this.duration).OnComplete(() => { if (callback != null)
{
callback.Invoke();
}
});
}
protected virtual void RaiseOnComplete(object sender, object userArg)
{
CompleteHandler handler = OnComplete;
if (handler != null)
{
handler(this, userArg);
}
}
public override async Task <bool> CheckCompletion()
{
try
{
Log.Debug("Tezos: check refund event");
var contractAddress = Xtz.SwapContractAddress;
var api = (ITezosBlockchainApi)Xtz.BlockchainApi;
for (var page = 0; ; page++)
{
var txs = (await api
.GetTransactionsAsync(contractAddress, page)
.ConfigureAwait(false))
.Cast <TezosTransaction>()
.ToList();
if (txs.Count == 0)
{
break;
}
var swapTimeReached = false;
foreach (var tx in txs)
{
if (tx.To == contractAddress && tx.IsSwapRefund(Swap.SecretHash))
{
CompleteHandler?.Invoke(this);
return(true);
}
var blockTimeUtc = tx.BlockInfo.BlockTime.ToUniversalTime();
var swapTimeUtc = Swap.TimeStamp.ToUniversalTime();
if (blockTimeUtc < swapTimeUtc)
{
swapTimeReached = true;
break;
}
}
if (swapTimeReached)
{
break;
}
}
}
catch (Exception e)
{
Log.Error(e, "Tezos refund control task error");
}
CancelHandler?.Invoke(this);
return(true);
}
private IEnumerator HandleSceneActivation(CompleteHandler callback, object param)
{
this._asyncOperation.allowSceneActivation = true;
while (!this._asyncOperation.isDone)
{
yield return(0);
}
this._asyncOperation = null;
callback.Invoke(this, param);
}
// create a method that will scan a directory (including all sub folders)
// looking for all files that have the .txt or .doc extension
// the start path is passed into the "startPath" parameter.
// note the method must not block the main thread and should process the data in the background.
// the code must call the "done" handler with an array of file names when complete.
public void Exercise4(string startPath, CompleteHandler done)
{
new Thread(() =>
{
List <string> files = new List <string>();
files.AddRange(Directory.GetFiles(startPath, "*.txt", SearchOption.AllDirectories));
files.AddRange(Directory.GetFiles(startPath, "*.doc", SearchOption.AllDirectories));
done(files.ToArray());
}
).Start();
}
public void Test()
{
var storage = Substitute.For<INoteStorage>();
var note = new Note("My note", "Body");
note.GetType().GetProperty("Id").SetValue(note, "10", null);
storage.Load("10").Returns(note);
var handler = new CompleteHandler(storage);
handler.Invoke(new CompleteNote("10"));
Assert.True(note.IsCompleted);
storage.Received().Save(note);
}
public override Task <bool> CheckCompletion()
{
var refundTimeReached = DateTime.UtcNow >= RefundTimeUtc;
Log.Debug("Refund time check for swap {@swapId}", Swap.Id);
if (refundTimeReached)
{
CompleteHandler?.Invoke(this);
}
return(Task.FromResult(refundTimeReached));
}
public void Test()
{
var storage = Substitute.For <INoteStorage>();
var note = new Note("My note", "Body");
note.GetType().GetProperty("Id").SetValue(note, "10", null);
storage.Load("10").Returns(note);
var handler = new CompleteHandler(storage);
handler.Invoke(new CompleteNote("10"));
Assert.True(note.IsCompleted);
storage.Received().Save(note);
}
public void LoadTimeSlots()
{
timeInput.SetTextDateTime(CompleteHandler.GetInstance().GetRequestedReservation());
List <Room> rooms = CompleteHandler.GetInstance().GetAvailableRooms();
DateTime date = CompleteHandler.GetInstance().GetRequestedDate();
for (int i = 0; i < rooms.Count; ++i)
{
List <Reservation> reservations = rooms[i].reservations[date];
for (int j = 0; j < reservations.Count; ++j)
{
AddTimeSlot(rooms[i], reservations[j]);
}
}
}
public static void Cancel()
{
if (_lb != null)
{
_lb.Cancel();
_lb = null;
}
if (_loader != null)
{
_loader.Cancel();
_loader = null;
}
_completeHandler = null;
_progressHandler = null;
_errorHandler = null;
}
/// <summary>
/// The request for user authorization to access app-related data.
/// This method allows you to <a href="https://developer.apple.com/documentation/apptrackingtransparency/attrackingmanager/3547037-requesttrackingauthorization">request the user permission dialogue</a>.
/// </summary>
/// <exception cref="InvalidOperationException">App tracking transparency request is already triggered and awaiting completion</exception>
public static void Request(CompleteHandler callback)
{
if (_completeCallback != null)
{
throw new InvalidOperationException("App tracking transparency request is already triggered and awaiting completion");
}
_completeCallback = callback;
#if NATIVE_REQUEST
if (Application.platform == RuntimePlatform.IPhonePlayer)
{
CAS.iOS.CASExterns.CASURequestATT(ATTRequestCompleted);
return;
}
#endif
ATTRequestCompleted(( int )AuthorizationStatus.NotDetermined);
}
/// <summary>
/// 增加deadLine时间处理
/// </summary>
/// <param name="eHandle"></param>
/// <param name="cHandle"></param>
/// <returns></returns>
private int AddDeadLine(double deadLine, CompleteHandler cHandle, EveryHandle eHandle = null)
{
//Timer.CreateTimer();
if (cHandle == null)
{
return(-1);
}
double nt = GetNowTime();
int tId = GetTimeId();
completeHandles.Add(tId, cHandle);
completeTimes.Add(tId, deadLine);
if (eHandle != null)
{
everySecondHandles.Add(tId, new EveryHandleData(eHandle));
}
return(tId);
}
// Start is called before the first frame update
void Start()
{
if (instance != null)
{
Destroy(this);
}
else
{
madeReservations = new Dictionary <Reservation, Room>();
for (int i = 0; i < rooms.Count; ++i)
{
rooms[i].Init();
}
suitableRooms = new List <Room>();
DontDestroyOnLoad(this.gameObject);
instance = this;
}
}
public override async Task <bool> CheckCompletion()
{
try
{
Log.Debug("Ethereum: check redeem event");
var wsUri = Web3BlockchainApi.WsUriByChain(Eth.Chain);
var web3 = new Web3(new WebSocketClient(wsUri));
var redeemEventHandler = web3.Eth
.GetEvent <RedeemedEventDTO>(Eth.SwapContractAddress);
var filter = redeemEventHandler
.CreateFilterInput <byte[]>(Swap.SecretHash);
var events = await redeemEventHandler
.GetAllChanges(filter)
.ConfigureAwait(false);
if (events.Count > 0)
{
Secret = events.First().Event.Secret;
Log.Debug("Redeem event received with secret {@secret}", Convert.ToBase64String(Secret));
CompleteHandler?.Invoke(this);
return(true);
}
}
catch (Exception e)
{
Log.Error(e, "Ethereum redeem control task error");
}
if (DateTime.UtcNow >= RefundTimeUtc)
{
Log.Debug("Time for refund reached");
CancelHandler?.Invoke(this);
return(true);
}
return(false);
}
public void Init()
{
for (int i = 0; i < reservationDisplays.Count; ++i)
{
Destroy(reservationDisplays[i].gameObject);
}
reservationDisplays.Clear();
List <Reservation> res = CompleteHandler.GetInstance().GetMadeReservationsAsList();
if (res == null)
{
return;
}
Debug.Log("making display for " + res.Count);
for (int i = 0; i < res.Count; ++i)
{
addDisplay(CompleteHandler.GetInstance().GetMadeReservations()[res[i]], res[i]);
}
}
public void OnReserve()
{
Reservation timeSlot = timeInput.GetSelectedTime();
Room room = selectedTime.room;
//Room room = CompleteHandler.GetInstance().GetRoomWithNumber(selectedTime.room.roomNumber);
//if(!room.reservations.ContainsKey(timeSlot.startTime.Date))
//{
// room.reservations.Add(timeSlot.startTime.Date, new List<Reservation>());
//}
//room.reservations[timeSlot.startTime.Date].Add(timeSlot);
Debug.Log("made reservation in room: " + room.roomNumber + " with reservation:\n" + timeSlot.ToString());
CompleteHandler.GetInstance().CreateReservation(timeSlot, room);
for (int i = 0; i < availableTimeViews.Count; ++i)
{
Destroy(availableTimeViews[i]);
}
availableTimeViews.Clear();
}
public void PostStatusesWithPic(String text, String path, CompleteHandler handler)
{
if (m_netEngine == null)
m_netEngine = new DoubanNetEngine();
RestRequest request = new RestRequest();
request.Method = WebMethod.Post;
request.Path = "shuo/v2/statuses/";
request.AddParameter("text", text);
request.AddParameter("source", DoubanSdkData.AppKey);
//path = "";
if (!String.IsNullOrEmpty(path))
{
IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication();
if (!file.FileExists(path))
{
file.Dispose();
DoubanEventArgs args = new DoubanEventArgs();
args.errorCode = DoubanSdkErrCode.XPARAM_ERR;
handler(args);
return;
}
file.Dispose();
string picType = System.IO.Path.GetExtension(path);
string picName = System.IO.Path.GetFileName(path);
if ("png" == picType)
{
request.AddFile("image", picName, path, "image/png");
}
else
{
request.AddFile("image", picName, path, "image/jpeg");
}
}
m_netEngine.SendRequest(request, (DoubanSdkResponse response) =>
{
if (response.errCode == DoubanSdkErrCode.SUCCESS)
{
DoubanEventArgs args = new DoubanEventArgs();
args.errorCode = DoubanSdkErrCode.SUCCESS;
args.specificCode = response.specificCode;
handler(args);
}
else
{
DoubanEventArgs args = new DoubanEventArgs();
args.errorCode = response.errCode;
args.specificCode = response.specificCode;
handler(args);
}
});
}
public DeviceRestartRequest(Enum id, CompleteHandler onComplete)
{
this.Id = id;
this.OnComplete = onComplete;
}
public DeviceRestartRequest()
{
this.OnComplete = null;
this.Id = default(Enum);
}
public void AddComments(String id, String text, CompleteHandler hanlder)
{
if (m_shuoAPI == null)
m_shuoAPI = new ShuoAPI();
m_shuoAPI.AddComments(id, text, hanlder);
}
public void PostStatusesWithPic(String text, String path, CompleteHandler hanlder)
{
if (m_shuoAPI == null)
m_shuoAPI = new ShuoAPI();
new System.Threading.Thread(() =>
{
m_shuoAPI.PostStatusesWithPic(text, path, hanlder);
}).Start();
}
