/// <summary>
/// Called when [fetch request].
/// </summary>
/// <param name="package">The package.</param>
/// <returns></returns>
private async Task <WebPackage> OnFetchRequest(WebPackage package)
{
WebPackage webPackage = new WebPackage();
webPackage.Id = package.Id;
webPackage.PackageType = PackageType.FetchResult;
try
{
if (package.FetchData.Type == typeof(AssassinImage).AssemblyQualifiedName)
{
package.EntityData.LoadImages();
webPackage.FetchData.Result_Images = new List <AssassinImage>()
{
package.EntityData.GetImage() ?? new AssassinImage()
};
}
else
{
if (package.FetchData.IdList)
{
webPackage.FetchData.Result_IdList = new DataRepository().GetIdList(package.FetchData.Type, package.FetchData.Query, package.FetchData.TakeCount).ToList();
}
else if (package.FetchData.TakeCount > 0)
{
IList result = new DataRepository().GetFirst(webPackage.FetchData.Type, webPackage.FetchData.TakeCount, webPackage.FetchData.Skip, webPackage.FetchData.Query, webPackage.FetchData.IncludeAll);
webPackage.FetchData.Result_Entities = result.Cast <BaseModel>().ToList();
}
else if (!string.IsNullOrEmpty(webPackage.FetchData.Query))
{
IList result = new DataRepository().GetListByQuery(webPackage.FetchData.Type, webPackage.FetchData.Query, webPackage.FetchData.IncludeAll);
AssassinDataService.OnNotify?.Invoke(this, "returning " + result.Count + " items", LogLevel.Debug);
webPackage.FetchData.Result_Entities = result.Cast <BaseModel>().ToList();
}
}
return(webPackage);
}
catch (Exception ex)
{
webPackage.FetchData.Result_Exception = ex;
AssassinDataService.OnNotify.Invoke(this, ex.ToText("Fetch error"), LogLevel.Error);
}
await Task.Delay(1);
return(webPackage);
}
/// <summary>
/// Called when a streaming package was received
/// </summary>
/// <param name="package">The package.</param>
/// <param name="stream">The stream.</param>
/// <returns>a task</returns>
private async Task OnStreaming(WebPackage package, IStream stream)
{
try
{
AssassinDataService.OnNotify?.Invoke(this, "Package received: " + package.Method, LogLevel.Debug);
if (package.Method == PackageMethod.Insert)
{
if (package.AssassinImage != null)
{
package.AssassinImage.Save();
}
else
{
await DataHandler.Insert(package.EntityData);
}
}
else if (package.Method == PackageMethod.Update)
{
if (package.AssassinImage != null)
{
package.AssassinImage.Save();
}
else
{
await DataHandler.Update(package.EntityData);
}
}
else if (package.Method == PackageMethod.Delete)
{
if (package.AssassinImage != null)
{
package.AssassinImage.Delete();
}
else
{
package.EntityData.Archived = true;
await DataHandler.Update(package.EntityData);
}
}
}
catch (Exception ex)
{
AssassinDataService.OnNotify?.Invoke(this, ex.ToText("Package error"), LogLevel.Error);
}
}
/// <summary>
/// Adds the specific data model on the server.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data">The <see cref="object" /></param>
/// <returns>a task</returns>
public async Task Insert <T>(T data) where T : BaseModel
{
try
{
WebPackage package = new WebPackage()
{
PackageType = PackageType.Command,
EntityData = data,
Method = PackageMethod.Insert
};
this.webservice.Send(package);
await Task.Delay(1);
}
catch (Exception ex)
{
AssassinDataService.OnNotify?.Invoke(this, ex.ToText("Error sending data to server - method Insert failed."), LogLevel.Error);
}
}
/// <summary>
/// Deletes a image from the server.
/// </summary>
/// <param name="image">The image.</param>
/// <returns>a task</returns>
internal async Task DeleteImage(AssassinImage image)
{
try
{
WebPackage package = new WebPackage()
{
PackageType = PackageType.Command,
AssassinImage = image,
Method = PackageMethod.Delete
};
this.webservice.Send(package);
image.Synced = true;
await Task.Delay(1);
}
catch (Exception ex)
{
AssassinDataService.OnNotify?.Invoke(this, ex.ToText("Error sending data to server - method Delete failed."), LogLevel.Error);
}
}
/// <summary>
/// Requests the images for a specific entity from the server.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="BaseModel">The BaseModel.</param>
/// <returns>a task</returns>
internal async Task <T> GetImage <T>(T data) where T : BaseModel
{
WebPackage package = new WebPackage()
{
PackageType = PackageType.Fetch,
EntityData = data
};
try
{
List <T> result = new List <T>();
package.FetchData = new FetchData()
{
Type = typeof(AssassinImage).AssemblyQualifiedName
};
var fetchResult = await this.webservice.Fetch(package);
if (fetchResult.FetchData.Result_Exception != null)
{
throw fetchResult.FetchData.Result_Exception;
}
if (fetchResult.FetchData.Result_Images != null)
{
data.SetImage(fetchResult.FetchData.Result_Images.FirstOrDefault());
fetchResult.FetchData.Result_Images.FirstOrDefault().Save();
}
return(data);
}
catch (Exception ex)
{
AssassinDataService.OnNotify?.Invoke(this, ex.ToText("Error fetching data from server - method GetAll failed."), LogLevel.Error);
}
return(null);
}
private async Task <WebPackage> OnAuthenticate(WebPackage package)
{
return(await AuthenticateUser?.Invoke(package));
}
/// <summary>
/// The GetPackage
/// </summary>
/// <returns>The <see cref="Task{SocketMessage}"/></returns>
public async Task <WebPackage> GetPackage()
{
while (SocketStream.Connected && !(SocketStream.MainStream as NetworkStream).DataAvailable)
{
await Task.Delay(1);
}
WebPackage package = null;
try
{
if (SocketStream.Connected)
{
int packageSize = 0;
List <byte> totalPackage = new List <byte>();
DateTime lastReceive = DateTime.MinValue;
while (package == null)
{
// Receive header
if (SocketStream.Client.Available >= 32)
{
byte[] sizeBuffer = new byte[32];
await SocketStream.MainStream.ReadAsync(sizeBuffer, 0, 32);
packageSize = BitConverter.ToInt32(sizeBuffer, 0);
}
// Receive package
while (totalPackage.Count < packageSize)
{
if (SocketStream.Client.Available > 0)
{
lastReceive = DateTime.Now;
int missing = packageSize - totalPackage.Count;
int readBuffer = SocketStream.Client.Available - missing > 0 ? missing : SocketStream.Client.Available;
byte[] buffer = new byte[readBuffer];
await SocketStream.MainStream.ReadAsync(buffer, 0, readBuffer);
totalPackage.AddRange(buffer);
}
// TIMEOUT CHECK
if (lastReceive != DateTime.MinValue && lastReceive.AddSeconds(30) < DateTime.Now)
{
throw new Exception("Stream Timeout");
}
}
if (totalPackage.Count > 0)
{
package = totalPackage.ToArray().FromBytes(typeof(WebPackage)) as WebPackage;
Debug.WriteLine("received package of size: " + (packageSize / 1000) + " kbytes");
}
}
}
}
catch (Exception ex)
{
throw new Exception("Package receiving error: " + ex.Message);
}
return(package);
}
