private void button1_Click(object sender, EventArgs e)
{
SharePointFtpService.SharePointFtpServiceClient client = new SharePointFtpService.SharePointFtpServiceClient();
try
{
OpenRequest request = new OpenRequest()
{
Url = textUrl.Text,
Username = textUser.Text,
Password = textPassword.Text
};
OpenResponse result = client.Open(request);
textOutput.Text += string.Format("SUCCESS. Web URL: {0}, Folder URL: {1}\n\r", result.WebUrl, result.FolderUrl);
}
catch (FaultException <InvalidUrlFault> fault)
{
textOutput.Text += string.Format("FAILURE. The URL {0} is not valid.", fault.Detail.Url);
}
catch (FaultException <Exception> fault)
{
textOutput.Text += string.Format("Unexpected Error: {0}.", fault.Detail.Message);
}
finally
{
if (client.State == System.ServiceModel.CommunicationState.Opened)
{
client.Close();
}
}
}
public async Task Handle(JupyterRequestContext context)
{
var executeRequest = GetRequest(context);
context.RequestHandlerStatus.SetAsBusy();
var executionCount = executeRequest.Silent ? _executionCount : Interlocked.Increment(ref _executionCount);
var command = new SubmitCode(executeRequest.Code, "csharp");
var id = Guid.NewGuid();
var transient = new Dictionary <string, object> {
{ "display_id", id.ToString() }
};
var openRequest = new OpenRequest(context, executeRequest, executionCount, transient);
OpenRequests[command] = openRequest;
try
{
var kernelResult = await Kernel.SendAsync(command);
openRequest.AddDisposable(kernelResult.KernelEvents.Subscribe(OnKernelResultEvent));
}
catch (Exception e)
{
OpenRequests.TryRemove(command, out _);
var errorContent = new Error(
eName: "Unhandled Exception",
eValue: $"{e.Message}"
);
if (!executeRequest.Silent)
{
// send on io
var error = Message.Create(
errorContent,
context.Request.Header);
context.IoPubChannel.Send(error);
// send on stderr
var stdErr = new StdErrStream(errorContent.EValue);
var stream = Message.Create(
stdErr,
context.Request.Header);
context.IoPubChannel.Send(stream);
}
// reply Error
var executeReplyPayload = new ExecuteReplyError(errorContent, executionCount: executionCount);
// send to server
var executeReply = Message.CreateResponse(
executeReplyPayload,
context.Request);
context.ServerChannel.Send(executeReply);
context.RequestHandlerStatus.SetAsIdle();
}
}
public static int SendRequest(PlayHavenBinding.RequestType type, string placement, bool showsOverlayImmediately)
{
IPlayHavenRequest request = null;
switch (type)
{
case PlayHavenBinding.RequestType.Open:
request = new OpenRequest(placement); // placement is actually customUDID
request.OnSuccess += HandleOpenRequestOnSuccess;
request.OnError += HandleOpenRequestOnError;
break;
case PlayHavenBinding.RequestType.Metadata:
request = new MetadataRequest(placement);
request.OnSuccess += HandleMetadataRequestOnSuccess;
request.OnError += HandleMetadataRequestOnError;
request.OnWillDisplay += HandleMetadataRequestOnWillDisplay;
request.OnDidDisplay += HandleMetadataRequestOnDidDisplay;
break;
case PlayHavenBinding.RequestType.Content:
request = new ContentRequest(placement);
request.OnError += HandleContentRequestOnError;
request.OnDismiss += HandleContentRequestOnDismiss;
request.OnReward += HandleContentRequestOnReward;
request.OnPurchasePresented += HandleRequestOnPurchasePresented;
request.OnWillDisplay += HandleContentRequestOnWillDisplay;
request.OnDidDisplay += HandleContentRequestOnDidDisplay;
break;
case PlayHavenBinding.RequestType.Preload:
request = new ContentPreloadRequest(placement);
request.OnError += HandleContentRequestOnError;
request.OnSuccess += HandlePreloadRequestOnSuccess;
break;
case PlayHavenBinding.RequestType.CrossPromotionWidget:
request = new ContentRequest("more_games");
request.OnError += HandleCrossPromotionWidgetRequestOnError;
request.OnDismiss += HandleCrossPromotionWidgetRequestOnDismiss;
request.OnWillDisplay += HandleCrossPromotionWidgetRequestOnWillDisplay;
request.OnDidDisplay += HandleCrossPromotionWidgetRequestOnDidDisplay;
break;
}
if (request != null)
{
request.Send(showsOverlayImmediately);
return(request.HashCode);
}
return(0);
}
/// <summary>
/// Starts the async open request
/// </summary>
/// <param name="callback"></param>
/// <param name="configuration"></param>
/// <param name="token"></param>
/// <returns></returns>
public IAsyncResult BeginOpenRequest(AsyncCallback callback, ICloudStorageConfiguration configuration, ICloudStorageAccessToken token)
{
// build the request data structure
OpenRequest request = new OpenRequest();
request.callback = callback;
request.result = new AsyncResultEx(request);
request.config = configuration;
request.token = token;
// add to threadpool
ThreadPool.QueueUserWorkItem(OpenRequestCallback, request);
// return the result
return request.result;
}
public Task Handle(JupyterRequestContext context)
{
var executeRequest = context.GetRequestContent <ExecuteRequest>() ?? throw new InvalidOperationException($"Request Content must be a not null {typeof(ExecuteRequest).Name}");
context.RequestHandlerStatus.SetAsBusy();
var command = new SubmitCode(executeRequest.Code);
var id = command.Id;
var transient = new Dictionary <string, object> {
{ "display_id", id.ToString() }
};
var executionCount = executeRequest.Silent ? _executionCount : Interlocked.Increment(ref _executionCount);
_openRequests[id] = new OpenRequest(context, executeRequest, executionCount, id, transient);
return(_kernel.SendAsync(command));
}
public IActionResult Open(IFormCollection openRequest)
{
OpenRequest open = new OpenRequest();
if (openRequest.Files.Count != 0)
{
open.File = openRequest.Files[0];
}
open.Password = openRequest["Password"];
if (openRequest["SheetIndex"].Count != 0)
{
open.SheetIndex = int.Parse(openRequest["SheetIndex"]);
}
open.SheetPassword = openRequest["SheetPassword"];
return(Content(Workbook.Open(open)));
}
/// <summary>
/// Starts the async open request
/// </summary>
/// <param name="callback"></param>
/// <param name="configuration"></param>
/// <param name="token"></param>
/// <returns></returns>
public IAsyncResult BeginOpenRequest(AsyncCallback callback, ICloudStorageConfiguration configuration, ICloudStorageAccessToken token)
{
// build the request data structure
OpenRequest request = new OpenRequest();
request.callback = callback;
request.result = new AsyncResultEx(request);
request.config = configuration;
request.token = token;
// add to threadpool
ThreadPool.QueueUserWorkItem(OpenRequestCallback, request);
// return the result
return(request.result);
}
public ActionResult Index(string target, string action)
{
lock (_lock)
{
if (!string.IsNullOrEmpty(target))
{
string method = Request.HttpMethod.ToLower();
//if (!string.IsNullOrEmpty(action))
//{
// method = action.ToLower().Trim();
//}
StringBuilder urlBuilder = new StringBuilder();
urlBuilder.Append(MConfig.Get <String>("remoteRoot"));
urlBuilder.Append(MConfig.Get <string>(target.Trim().ToLower()));
urlBuilder.AppendFormat("userId={0}", UserInfo.UserSysNo);
switch (method)
{
case "get":
{
NameValueCollection keyValuePair = Request.QueryString;
foreach (string key in keyValuePair.Keys)
{
urlBuilder.AppendFormat("&{0}={1}", key, keyValuePair[key]);
}
break;;
}
case "post":
{
NameValueCollection keyValuePair = Request.Form;
foreach (string key in keyValuePair.Keys)
{
urlBuilder.AppendFormat("&{0}={1}", key, keyValuePair[key]);
}
break;
}
}
var proxy = OpenRequest.Create(urlBuilder.ToString(), method);
var resp = proxy.GetResponse();
return(Content(resp.ResponseText));
}
return(new EmptyResult());
}
}
/// <summary>
/// This method implements a asyncallback for the open
/// request, which is describe in BeginOpenRequest
/// </summary>
/// <param name="state">A reference to the start object</param>
private void OpenRequestCallback(object state)
{
// cast the request
OpenRequest req = state as OpenRequest;
try
{
// perform the request
req.OperationResult = Open(req.config, req.token);
}
catch (Exception e)
{
// failure to login
var openRequest = req.result.AsyncState as BackgroundRequest;
openRequest.OperationResult = null;
openRequest.errorReason = e;
}
// call the async callback
req.callback(req.result);
}
public Task <T> ExecuteAsync <T>()
{
var client = new RestClient();
var taskCompletionSource = new TaskCompletionSource <T>();
RestRequest request = new RestRequest("TestCall", Method.POST);
OpenRequest obj = new OpenRequest
{
User = userId,
PIN = PIN
};
request.AddObject(obj);
try
{
client.ExecuteAsync <T>(request, (response) => taskCompletionSource.SetResult(response.Data));
}
catch (Exception e)
{
taskCompletionSource.TrySetException(e);
}
return(taskCompletionSource.Task);
}
public ActionResult ConditionalFormattingOpen(OpenRequest openRequest)
{
return(Content(Workbook.Open(openRequest)));
}
public void TestOpenRequest()
{
var openRequest = new OpenRequest();
openRequest.Init(new StringReader("OPN"));
}
/// <summary>
/// Finishs the async open request
/// </summary>
/// <param name="asyncResult"></param>
/// <returns></returns>
public ICloudStorageAccessToken EndOpenRequest(IAsyncResult asyncResult)
{
OpenRequest req = asyncResult.AsyncState as OpenRequest;
return(req.OperationResult as ICloudStorageAccessToken);
}
