public async Task <ReturnMessageInfo> setHotelLoginTime(LoginInfo loginInfo)
{
ReturnMessageInfo msgInfo = new ReturnMessageInfo();
BaseDL bdl = new BaseDL();
NpgsqlParameter[] para = new NpgsqlParameter[3];
para[0] = new NpgsqlParameter("@hotelcode", NpgsqlDbType.Varchar)
{
Value = loginInfo.HotelCode
};
para[1] = new NpgsqlParameter("@usercode", NpgsqlDbType.Varchar)
{
Value = loginInfo.UserCode
};
if (loginInfo.SessionFlag == false)
{
para[2] = new NpgsqlParameter("@logindate", NpgsqlDbType.Timestamp)
{
Value = DateTime.Now
}
}
;
else
{
para[2] = new NpgsqlParameter("@logindate", NpgsqlDbType.Timestamp)
{
Value = DateTime.Now.AddMinutes(-2)
}
};
string sql = "update mst_hoteluser set logindate=@logindate where hotel_code=@hotelcode and usercode=@usercode";
msgInfo = await bdl.InsertUpdateDeleteData(sql, para);
return(msgInfo);
}
public async Task <PropagationEffects> PropagateAsync(ReturnMessageInfo returnMessageInfo)
{
this.methodEntity.PropGraph.ResetUpdateCount();
Logger.LogS("MethodEntityGrain", "PropagateAsync-return", "Propagation for {0} ", returnMessageInfo.Caller);
//PropGraph.Add(lhs, retValues);
if (returnMessageInfo.LHS != null)
{
var possibleTypes = returnMessageInfo.ResultPossibleTypes.ToList();
await this.methodEntity.PropGraph.DiffPropAsync(possibleTypes, returnMessageInfo.LHS, returnMessageInfo.PropagationKind);
}
/// We need to recompute possible calless
var effects = await InternalPropagateAsync(returnMessageInfo.PropagationKind);
Logger.LogS("MethodEntityGrain", "PropagateAsync-return", "End Propagation for {0} ", returnMessageInfo.Caller);
//if (returnMessageInfo.PropagationKind == PropagationKind.REMOVE_TYPES)
//{
// var invoInfo = from callNode in this.methodEntity.PropGraph.CallNodes
// select this.methodEntity.PropGraph.GetInvocationInfo(callNode);
// await this.PopulateCalleesInfo(invoInfo);
//}
return(effects);
}
public async Task <IHttpActionResult> setLoginTime(LoginInfo loginInfo)
{
ReturnMessageInfo msgInfo = new ReturnMessageInfo();
msgInfo = await setHotelLoginTime(loginInfo);
return(Ok(msgInfo));
}
private Task CreateAndSendReturnMessageAsync(ReturnInfo returnInfo, PropagationKind propKind)
{
var returnMessageInfo = new ReturnMessageInfo(returnInfo.CallerContext.Caller, returnInfo.Callee, returnInfo.ResultPossibleTypes,
returnInfo.CallerContext.CallNode, returnInfo.CallerContext.LHS, propKind);
var source = new MethodEntityDescriptor(returnInfo.Callee);
var calleeMessage = new CalleeMessage(source, returnMessageInfo);
return(this.AnalyzeReturnAsync(returnMessageInfo.Caller, calleeMessage, propKind));
}
public async Task PropagateAndProcessAsync(ReturnMessageInfo returnMessageInfo)
{
await StatsHelper.RegisterMsg("MethodEntityGrain::PropagateAndProcess", this.GrainFactory);
var effects = await this.methodEntityPropagator.PropagateAsync(returnMessageInfo); //await this.PropagateAsync(returnMessageInfo);
await StatsHelper.RegisterPropagationUpdates(effects.NumberOfUpdates, effects.WorkListInitialSize, this.GrainFactory);
await ProcessEffectsAsync(effects);
}
private Task CreateAndSendReturnMessageAsync(ReturnInfo returnInfo, PropagationKind propKind)
{
var returnMessageInfo = new ReturnMessageInfo(returnInfo.CallerContext.Caller, returnInfo.Callee, returnInfo.ResultPossibleTypes,
returnInfo.CallerContext.CallNode, returnInfo.CallerContext.LHS, propKind);
var source = new MethodEntityDescriptor(returnInfo.Callee);
var calleeMessage = new CalleeMessage(source, returnMessageInfo);
//await WaitQueue(QUEUE_THRESHOLD);
this.messageWorkList.Enqueue(calleeMessage);
//this.messageWorkList.Add(calleeMessage);
return(Task.CompletedTask);
//return AnalyzeReturnAsync(returnMessageInfo.Caller, calleeMessage, propKind);
}
public async Task <Tuple <string, ReturnMessageInfo> > SelectJson(string sSQL, params NpgsqlParameter[] param)
{
ReturnMessageInfo msgInfo = new ReturnMessageInfo();
DataTable dt = new DataTable
{
TableName = "data"
};
try
{
var newCon = new NpgsqlConnection(conStr);
using (var adapt = new NpgsqlDataAdapter(sSQL, newCon))
{
NpgsqlCommand cmd = new NpgsqlCommand(sSQL, newCon);
cmd.CommandType = CommandType.Text;
if (param != null)
{
param = ChangeToDBNull(param);
adapt.SelectCommand.Parameters.AddRange(param);
}
newCon.Open();
await Task.Run(() => adapt.Fill(dt));
newCon.Close();
Logger.WithProperty("path", HttpContext.Current.Request.Path).Info("Success");
msgInfo.Status = "Success";
msgInfo.FailureReason = "";
msgInfo.ErrorDescription = "";
}
}
catch (PostgresException ex)
{
Logger.WithProperty("path", HttpContext.Current.Request.Path).Error(ex.Message);
string msg = ex.Message;
msgInfo.Status = "Error";
msgInfo.FailureReason = "1005";
msgInfo.ErrorDescription = "データベースエラー";
}
catch (Exception ex)
{
Logger.WithProperty("path", HttpContext.Current.Request.Path).Error(ex.Message);
string msg = ex.Message;
msgInfo.Status = "Error";
msgInfo.FailureReason = "1004";
msgInfo.ErrorDescription = "データベース接続エラー";
}
return(new Tuple <string, ReturnMessageInfo>(DataTableToJSONWithJSONNet(dt), msgInfo));
}
private async Task CreateAndSendReturnMessageAsync(ReturnInfo returnInfo, PropagationKind propKind)
{
var returnMessageInfo = new ReturnMessageInfo(returnInfo.CallerContext.Caller, returnInfo.Callee, returnInfo.ResultPossibleTypes,
returnInfo.CallerContext.CallNode, returnInfo.CallerContext.LHS, propKind);
var source = new MethodEntityDescriptor(returnInfo.Callee);
var calleeMessage = new CalleeMessage(source, returnMessageInfo);
await this.solutionManager.UpdateCounter(1);
//await WaitQueue(QUEUE_THRESHOLD);
this.messageWorkList.Enqueue(calleeMessage);
//this.messageWorkList.Add(calleeMessage);
//return TaskDone.Done;
}
public async Task <ReturnMessageInfo> InsertUpdateDeleteData(string sSQL, params NpgsqlParameter[] para)
{
ReturnMessageInfo msgInfo = new ReturnMessageInfo();
try
{
var newCon = new NpgsqlConnection(conStr);
NpgsqlCommand cmd = new NpgsqlCommand(sSQL, newCon)
{
CommandType = CommandType.Text
};
para = ChangeToDBNull(para);
cmd.Parameters.AddRange(para);
cmd.Connection.Open();
await cmd.ExecuteNonQueryAsync();
cmd.Connection.Close();
Logger.WithProperty("path", HttpContext.Current.Request.Path).Info("Success");
msgInfo.Status = "Success";
msgInfo.FailureReason = "";
msgInfo.ErrorDescription = "";
return(msgInfo);
}
catch (PostgresException ex)
{
Logger.WithProperty("path", HttpContext.Current.Request.Path).Error(ex.Message);
string msg = ex.Message;
msgInfo.Status = "Error";
msgInfo.FailureReason = "1005";
msgInfo.ErrorDescription = "データベースエラー";
return(msgInfo);
}
catch (Exception ex)
{
Logger.WithProperty("path", HttpContext.Current.Request.Path).Error(ex.Message);
string msg = ex.Message;
msgInfo.Status = "Error";
msgInfo.FailureReason = "1004";
msgInfo.ErrorDescription = "データベース接続エラー";
return(msgInfo);
}
}
public async Task <PropagationEffects> PropagateAsync(ReturnMessageInfo returnMessageInfo)
{
await StatsHelper.RegisterMsg("MethodEntityGrain::PropagateReturn", this.GrainFactory);
//if (status.Equals(EntityGrainStatus.Busy))
//{
// await Task.Delay(WAIT_TIME);
// if (status.Equals(EntityGrainStatus.Busy))
// {
// return new PropagationEffects();
// }
//}
var propagationEffects = await this.methodEntityPropagator.PropagateAsync(returnMessageInfo);
propagationEffects.SiloAddress = StatsHelper.GetMyIPAddr();
await StatsHelper.RegisterPropagationUpdates(propagationEffects.NumberOfUpdates, propagationEffects.WorkListInitialSize, this.GrainFactory);
return(propagationEffects);
}
internal ReturnMessage(IEntityDescriptor source, ReturnMessageInfo messageInfo)
: base(source)
{
this.ReturnMessageInfo = messageInfo;
}
internal CalleeMessage(IEntityDescriptor source, ReturnMessageInfo messageInfo)
: base(source)
{
this.ReturnMessageInfo = messageInfo;
}
private async Task HandleReturnEventAsync(ReturnMessageInfo retMessageInfo)
{
if (retMessageInfo.LHS != null)
{
//lock (this.MethodEntity)
{
await this.MethodEntity.PropGraph.DiffPropAsync(
Demarshaler.Demarshal(retMessageInfo.RVs),
Demarshaler.Demarshal(retMessageInfo.LHS),
retMessageInfo.PropagationKind);
// This should be Async
}
switch (retMessageInfo.PropagationKind)
{
case PropagationKind.ADD_TYPES:
await PropagateAsync();
break;
case PropagationKind.REMOVE_TYPES:
await PropagateDeleteAsync();
break;
}
}
}
/// <summary>
/// Async versions of DispachReturnMessage
/// </summary>
/// <param name="context"></param>
/// <param name="returnVariable"></param>
/// <param name="propKind"></param>
/// <returns></returns>
internal async Task DispachReturnMessageAsync(CallContext context, VariableNode returnVariable, PropagationKind propKind)
{
var caller = context.Caller;
var lhs = context.CallLHS;
var types = returnVariable != null ?
GetTypes(returnVariable, propKind) :
new HashSet<TypeDescriptor>();
// Diego TO-DO, different treatment for adding and removal
if (propKind == PropagationKind.ADD_TYPES && types.Count() == 0 && returnVariable != null)
{
var instTypes = new HashSet<TypeDescriptor>();
foreach (var iType in this.MethodEntity.InstantiatedTypes)
{
var isSubtype = await codeProvider.IsSubtypeAsync(iType,returnVariable.Type);
if (isSubtype)
{
instTypes.Add(iType);
}
}
//instTypes.UnionWith(
// this.MethodEntity.InstantiatedTypes
// .Where(iType => codeProvider.IsSubtypeAsync(iType,returnVariable.Type).Result));
//// .Where(iType => iType.IsSubtype(returnVariable.Type)));
foreach (var t in instTypes)
{
types.Add(t);
}
}
// Jump to caller
var destination = EntityFactory.Create(caller,this.dispatcher);
var retMessageInfo = new ReturnMessageInfo(
lhs,
types,
propKind, this.MethodEntity.InstantiatedTypes,
context.Invocation);
var returnMessage = new ReturnMessage(this.MethodEntity.EntityDescriptor, retMessageInfo);
//if (lhs != null)
{
await this.SendMessageAsync(destination, returnMessage);
}
//else
//{
// return new Task(() => { });
//}
}
public Task PropagateAndProcessAsync(ReturnMessageInfo returnMessageInfo)
{
this.SetRequestContext();
return(methodEntityGrain.PropagateAndProcessAsync(returnMessageInfo));
}
public Task <PropagationEffects> PropagateAsync(ReturnMessageInfo returnMessageInfo)
{
this.SetRequestContext();
return(methodEntityGrain.PropagateAsync(returnMessageInfo));
}
private void HandleReturnEvent(ReturnMessageInfo retMesssageInfo)
{
//PropGraph.Add(lhs, retValues);
this.MethodEntity.PropGraph.DiffProp(
Demarshaler.Demarshal(retMesssageInfo.RVs),
Demarshaler.Demarshal(retMesssageInfo.LHS),
retMesssageInfo.PropagationKind);
// This should be Async
switch (retMesssageInfo.PropagationKind)
{
case PropagationKind.ADD_TYPES:
Propagate();
break;
case PropagationKind.REMOVE_TYPES:
PropagateDelete();
break;
default:
throw new ArgumentException();
}
}
