} // The subroutine's return handler.
public SubroutineCatalogItem(Subroutine subroutine, IParameterHandler parameterHandler, IndexReference objectStack, ReturnHandler returnHandler)
{
Subroutine = subroutine;
ParameterHandler = parameterHandler;
ObjectStack = objectStack;
ReturnHandler = returnHandler;
}
private IWorkshopTree OutputContant(VarIndexAssigner lambdaAssigner, ActionSet actionSet, IWorkshopTree[] parameterValues)
{
ReturnHandler returnHandler = new ReturnHandler(
actionSet,
ReturnType?.GetGettableAssigner(new AssigningAttributes("lambda", actionSet.IsGlobal, false))
.GetValue(new GettableAssignerValueInfo(actionSet)
{
SetInitialValue = SetInitialValue.DoNotSet,
Inline = !MultiplePaths
}),
MultiplePaths);
actionSet = AssignContainedParameters(lambdaAssigner, actionSet, parameterValues).New(returnHandler);
if (Expression != null)
{
returnHandler.ReturnValue(Expression.Parse(actionSet));
}
else
{
Statement.Translate(actionSet);
}
returnHandler.ApplyReturnSkips();
return(returnHandler.GetReturnedValue());
}
/// <summary>
/// /*如果想使用cookie 连续访问某个域下的action 可以将static方法转为非静态的
/// 实例化单个HttpHelper*/
/// </summary>
/// <param name="url">url不带参数</param>
/// <param name="data">数据</param>
/// <param name="handler">回调函数</param>
public static void HttpGet(string url, object data, ReturnHandler handler)
{
if (data != null)
{
Type type = data.GetType();
PropertyInfo[] propertyInfos = type.GetProperties();
string urlParams = "?";
for (int i = 0; i < propertyInfos.Length; i++)
{
urlParams += propertyInfos[i].Name;
urlParams += "=";
urlParams += propertyInfos[i].GetValue(data);
if (i != propertyInfos.Length - 1)
urlParams += "&";
}
url += urlParams;
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.Method = "GET";
request.ContentType = "text/html;charset=UTF-8";
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
Stream myResponseStream = response.GetResponseStream();
StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));
string retString = myStreamReader.ReadToEnd();
myStreamReader.Close();
myResponseStream.Close();
handler(retString);
}
public IWorkshopTree Invoke(ActionSet actionSet, params IWorkshopTree[] parameterValues)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
for (int i = 0; i < parameterValues.Length; i++)
{
actionSet.IndexAssigner.Add(Parameters[i], parameterValues[i]);
}
if (Block != null)
{
ReturnHandler returnHandler = new ReturnHandler(actionSet, "lambda", MultiplePaths);
Block.Translate(actionSet.New(returnHandler));
returnHandler.ApplyReturnSkips();
return(returnHandler.GetReturnedValue());
}
else if (Expression != null)
{
return(Expression.Parse(actionSet));
}
else
{
throw new NotImplementedException();
}
}
public async Task <ReturnObject <LeadsDTO> > GetLeadById(int id)
{
try
{
// Validate leadObj params
if (id == 0)
{
return(ReturnHandler <LeadsDTO> .GetReturnObject(true, null, "Please select valid lead.", null));
}
// make an Sierra API request to fetch lead details by id
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_sierraConfig.Value.BaseUrl);
client.DefaultRequestHeaders.Add("Sierra-ApiKey", _sierraConfig.Value.APIKey);
var httpResponse = await client.GetAsync($"{apiName}/get/{id}");
var responseContent = await httpResponse.Content.ReadAsStringAsync();
var apiResponseObj = JsonConvert.DeserializeObject <GetLeadsDetailsDTO>(responseContent);
if (!apiResponseObj.Success)
{
return(ReturnHandler <LeadsDTO> .GetReturnObject(true, null, apiResponseObj.ErrorMessage, null));
}
var leadsData = _mapper.Map <LeadsDTO>(apiResponseObj.Data);
return(ReturnHandler <LeadsDTO> .GetReturnObject(false, null, "Lead details fetched successfully.", leadsData));
}
}
catch (Exception ex)
{
var error = new Error("", ex.Message, ErrorTypeKeys.ServiceError.ToString());
return(ReturnHandler <LeadsDTO> .GetReturnObject(true, error, "Some Error occurred while fetching details.", null));
}
}
public async Task <ReturnObject <LeadsPaginatedReturnDTO> > GetLeads(FetchLeadParams fetchObj)
{
try
{
// sanitize parameters
// make an Sierra API request to create lead
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_sierraConfig.Value.BaseUrl);
client.DefaultRequestHeaders.Add("Sierra-ApiKey", _sierraConfig.Value.APIKey);
var httpResponse = await client.GetAsync($"{apiName}/find?leadStatus=AllExceptDeleted&name={fetchObj.Name}&email={fetchObj.Email}&phone={fetchObj.Phone}&sortColumn=RegisteredDate&sortOrder=desc&pageSize={fetchObj.PageSize}&pageNumber={fetchObj.PageNumber}");
var responseContent = await httpResponse.Content.ReadAsStringAsync();
var apiResponseObj = JsonConvert.DeserializeObject <GetLeadsReturnDTO>(responseContent);
if (!apiResponseObj.Success)
{
return(ReturnHandler <LeadsPaginatedReturnDTO> .GetReturnObject(true, null, apiResponseObj.ErrorMessage, null));
}
var leadsData = _mapper.Map <LeadsPaginatedReturnDTO>(apiResponseObj.Data);
return(ReturnHandler <LeadsPaginatedReturnDTO> .GetReturnObject(false, null, "Leads fetched successfully.", leadsData));
}
}
catch (Exception ex)
{
var error = new Error("", ex.Message, ErrorTypeKeys.ServiceError.ToString());
return(ReturnHandler <LeadsPaginatedReturnDTO> .GetReturnObject(true, error, "Some Error occurred while fetching leads.", null));
}
}
public void SetupReturnHandler()
{
ReturnHandler = Controller.GetReturnHandler(ActionSet);
if (ReturnHandler != null)
{
ModifySet(a => a.New(ReturnHandler));
}
}
private void Register(ReturnHandler <CommandMessage <TCommand> > fullHandler)
{
var registrationType = typeof(ReturnHandler <CommandMessage <TCommand> >);
_registerHandler(new CommandHandlerRegistration(
typeof(TCommand),
registrationType,
fullHandler));
}
/// <summary>Outputs a constant block.</summary>
private IWorkshopTree OutputContantBlock(ActionSet actionSet, IWorkshopTree[] parameterValues)
{
ReturnHandler returnHandler = new ReturnHandler(actionSet, "lambda", MultiplePaths);
Statement.Translate(AssignContainedParameters(actionSet, parameterValues).New(returnHandler));
returnHandler.ApplyReturnSkips();
return(returnHandler.GetReturnedValue());
}
public ReturnHandler <CommandMessage <TCommand> > Resolve <TCommand>() where TCommand : class
{
ReturnHandler <CommandMessage <TCommand> > handler = async(msg, ct) =>
{
ReceivedCommands.Add(msg);
return(-1L);
};
return(handler);
}
void IWorkshopFunctionController.Build(ActionSet actionSet)
{
var returnHandlers = new List <ReturnHandler>();
// Create the switch that chooses the lambda.
SwitchBuilder lambdaSwitch = new SwitchBuilder(actionSet);
for (int i = 0; i < _compatibleLambdas.Count; i++)
{
var compatibleLambda = _compatibleLambdas[i];
_returnRecycler.Reset();
// Create the return handler for the option.
ReturnHandler returnHandler = new ReturnHandler(
actionSet,
compatibleLambda.Runner.ReturnType?.GetGettableAssigner(new AssigningAttributes("lambdaReturnValue", true, false))
// Get the IGettable
.GetValue(new GettableAssignerValueInfo(actionSet)
{
SetInitialValue = SetInitialValue.DoNotSet,
IndexReferenceCreator = _returnRecycler
}),
compatibleLambda.Runner.ReturnType != null);
returnHandlers.Add(returnHandler);
// The action set for the overload.
ActionSet optionSet = actionSet.ContainVariableAssigner().New(returnHandler).SetThisTypeLinker(compatibleLambda.TypeLinker);
// Go to next case
lambdaSwitch.NextCase(Element.Num(compatibleLambda.Identifier));
// Add the object variables of the selected method.
var callerObject = ((Element)optionSet.CurrentObject)[1];
// Add the class objects.
compatibleLambda.Runner.This?.AddObjectVariablesToAssigner(optionSet.ToWorkshop, callerObject, optionSet.IndexAssigner);
// Add parameters.
compatibleLambda.Runner.AddToAssigner(optionSet.IndexAssigner);
// then parse the block.
compatibleLambda.Runner.Build(optionSet, returnHandler);
}
// Finish the switch.
lambdaSwitch.Finish(((Element)actionSet.CurrentObject)[0]);
foreach (var returnHandler in returnHandlers)
{
returnHandler.ApplyReturnSkips();
}
}
public ReturnHandler <CommandMessage <TCommand> > Resolve <TCommand>() where TCommand : class
{
#pragma warning disable 1998
ReturnHandler <CommandMessage <TCommand> > handler = async(msg, ct) =>
{
ReceivedCommands.Add(msg);
return(-1L);
};
#pragma warning restore 1998
return(handler);
}
public HttpResponse async_method(HttpRequest request)
{
ReturnHandler handler = new ReturnHandler(long_time_method); //new thread started, in this case.
try{
IAsyncResult resultObj = handler.BeginInvoke((HttpRequest)request, new AsyncCallback(AsyncCompleted), "\nBeginInvoke: Асинхронные вызовы\n");
HttpResponse res = handler.EndInvoke(resultObj);
return(res);
}catch (Exception ex) {
Console.WriteLine("async_method. Exception: " + ex);
return(new HttpResponse(StatusCode.Ok, "empty_response4..."));
}
}
public void Build(ActionSet actionSet, ReturnHandler returnHandler)
{
CaptureEncoder.DecodeCaptured(actionSet, actionSet.CurrentObject, _lambda);
if (_lambda.Expression != null)
{
var expr = _lambda.Expression.Parse(actionSet);
// 'expr' will be null if the expression is a void method.
if (expr != null)
{
returnHandler.ReturnValue(expr);
}
}
else
{
_lambda.Statement.Translate(actionSet);
}
}
/// <summary>Outputs a constant block.</summary>
private IWorkshopTree OutputContantBlock(VarIndexAssigner lambdaAssigner, ActionSet actionSet, IWorkshopTree[] parameterValues)
{
ReturnHandler returnHandler = new ReturnHandler(actionSet, "lambda", MultiplePaths);
actionSet = AssignContainedParameters(lambdaAssigner, actionSet, parameterValues).New(returnHandler);
if (Expression != null)
{
returnHandler.ReturnValue(Expression.Parse(actionSet));
}
else
{
Statement.Translate(actionSet);
}
returnHandler.ApplyReturnSkips();
return(returnHandler.GetReturnedValue());
}
IWorkshopTree BuildInline(ICallInfo call)
{
ModifySet(a => a.New(Controller.Attributes.IsRecursive));
// Create parameter handlers
ParameterHandler = Controller.CreateParameterHandler(ActionSet, call.Parameters);
// Setup inline-recursive handler.
RecursiveStack stack = null;
if (!_subroutine && Controller.Attributes.IsRecursive)
{
stack = new RecursiveStack(this, Controller.StackIdentifier());
stack.Init();
ActionSet.Translate.MethodStack.Add(stack);
}
ModifySet(a => a.PackThis().ContainVariableAssigner());
// Setup the return handler.
if (call.ProvidedReturnHandler != null)
{
ReturnHandler = call.ProvidedReturnHandler;
ModifySet(a => a.New(call.ProvidedReturnHandler));
}
else
{
SetupReturnHandler();
}
SetParameters(call); // Set the parameters.
AddParametersToAssigner();
stack?.StartRecursiveLoop(); // Start the recursion loop.
Controller.Build(ActionSet); // Build the function contents.
ReturnHandler.ApplyReturnSkips(); // Returns will skip to this point, right before the recursive loop ends.
stack?.EndRecursiveLoop(); // End the recursive loop.
if (stack != null)
{
ActionSet.Translate.MethodStack.Remove(stack); // Remove recursion info from the stack.
}
return(ReturnHandler.GetReturnedValue());
}
public void Handle(Handler <CommandMessage <TCommand> > handler)
{
_handler = handler;
ReturnHandler <CommandMessage <TCommand> > composed = null;
if (_pipes.Count == 0)
{
composed = async(msg, ct) =>
{
if (_handler != null)
{
await _handler(msg, ct);
}
return(-1L);
};
}
else
{
while (_pipes.Count > 0)
{
var pipe = _pipes.Pop();
if (composed == null)
{
composed = async(msg, ct) =>
{
if (_handler != null)
{
await _handler(msg, ct);
}
return(-1L);
};
}
composed = pipe(composed);
}
}
Register(async(msg, ct) => await composed(msg, ct));
}
public IEnumerator RequestPhpService(string phpServerUri, ReturnHandler returnHandler)
{
WWWForm wwwform = new WWWForm();
wwwform.AddField("uin", 1);//PlayerId.ToString()); //测试用1
wwwform.AddField("sessionId", SessionId.ToString());
WWW www = new WWW(phpServerUri, wwwform);
yield return(www);
if (www.isDone && string.IsNullOrEmpty(www.error))
{
returnHandler(www.text);
}
else
{
TraceUtil.Log("访问PHP错误");
}
}
public async Task <ReturnObject <CreateLeadReturnDTO> > Create(CreateLeadDTO leadObj)
{
try
{
// Validate leadObj params
var validationObj = await ValidateLeadCreationParams(leadObj);
if (validationObj.Count > 0)
{
var validationMsg = string.Concat(validationObj.ToArray());
return(ReturnHandler <CreateLeadReturnDTO> .GetReturnObject(true, null, validationMsg, null));
}
// make an Sierra API request to create lead
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_sierraConfig.Value.BaseUrl);
client.DefaultRequestHeaders.Add("Sierra-ApiKey", _sierraConfig.Value.APIKey);
var stringPayload = await Task.Run(() => JsonConvert.SerializeObject(leadObj));
var httpContent = new StringContent(stringPayload, Encoding.UTF8, "application/json");
var httpResponse = await client.PostAsync(apiName, httpContent);
var responseContent = await httpResponse.Content.ReadAsStringAsync();
var apiResponseObj = JsonConvert.DeserializeObject <CreateLeadResponseDTO>(responseContent);
if (!apiResponseObj.Success)
{
return(ReturnHandler <CreateLeadReturnDTO> .GetReturnObject(true, null, apiResponseObj.ErrorMessage, null));
}
}
return(ReturnHandler <CreateLeadReturnDTO> .GetReturnObject(false, null, "Lead created successfully.", null));
}
catch (Exception ex)
{
var error = new Error("", ex.Message, ErrorTypeKeys.ServiceError.ToString());
return(ReturnHandler <CreateLeadReturnDTO> .GetReturnObject(true, error, "Some Error occurred while creating lead.", null));
}
}
/// <summary>
/// /*如果想使用cookie 连续访问某个域下的action 可以将static方法转为非静态的
/// 实例化单个HttpHelper*/
/// </summary>
/// <param name="url">url不带参数</param>
/// <param name="data">数据</param>
/// <param name="handler">回调函数</param>
public static void HttpPost(string url, object data, ReturnHandler handler)
{
string urlParams = string.Empty;
if (data != null)
{
Type type = data.GetType();
PropertyInfo[] propertyInfos = type.GetProperties();
for (int i = 0; i < propertyInfos.Length; i++)
{
urlParams += propertyInfos[i].Name;
urlParams += "=";
urlParams += propertyInfos[i].GetValue(data);
if (i != propertyInfos.Length - 1)
urlParams += "&";
}
url += "?" + urlParams;
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
//request.ContentLength = Encoding.UTF8.GetByteCount(urlParams);
request.CookieContainer = cookie;
Stream myRequestStream = request.GetRequestStream();
StreamWriter myStreamWriter = new StreamWriter(myRequestStream, Encoding.GetEncoding("gb2312"));
myStreamWriter.Write(urlParams);
myStreamWriter.Close();
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
response.Cookies = cookie.GetCookies(response.ResponseUri);
Stream myResponseStream = response.GetResponseStream();
StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));
string retString = myStreamReader.ReadToEnd();
myStreamReader.Close();
myResponseStream.Close();
handler(retString);
}
public void ProcessResults(ChosenCards results)
{
foreach (var chosenCard in results)
{
chosenCard.Reveal();
}
var handler = new ReturnHandler(results.Count, _e);
_e.Enqueue(new SelectCards(
_e.Controller,
p =>
{
p.MinCount = 0;
p.MaxCount = results.Count;
p.Text = String.Format("Select {0} card(s) to return to hand.", results.Count);
p.SetValidator(_e._graveyardFilter);
p.Zone = Zone.Graveyard;
p.OwningCard = _e.Source.OwningCard;
p.ProcessDecisionResults = handler;
p.ChooseDecisionResults = handler;
}
));
}
public ReturnsManager(ModelI m)
{
dataBase = m;
returnHandler = new ReturnHandler(returnItem);
}
public CommandHandlerModule(ReturnHandler <CommandMessage> finalHandler = null) => _finalHandler = finalHandler;
void SetupReturnHandler()
{
ReturnHandler = new ReturnHandler(ActionSet, Determiner.GroupName(), Determiner.MultiplePaths());
ModifySet(a => a.New(ReturnHandler));
}
public virtual object get(object pId)
{
return(ReturnHandler.set(adapter.get(pId)));
}
public virtual object set(object pData)
{
return(ReturnHandler.set(adapter.set((DataSet)pData)));
// return ReturnHandler.set(adapter.set(pData));
}
