public StatementAgentInstanceFactoryUpdate(StatementContext statementContext, EPServicesContext services, EventType streamEventType, UpdateDesc desc, InternalRoutePreprocessView onExprView, InternalEventRouterDesc routerDesc, SubSelectStrategyCollection subSelectStrategyCollection)
: base(statementContext.Annotations)
{
_statementContext = statementContext;
_services = services;
_streamEventType = streamEventType;
_desc = desc;
_onExprView = onExprView;
_subSelectStrategyCollection = subSelectStrategyCollection;
_routerDesc = routerDesc;
}
public InternalEventRouterDesc(UpdateDesc updateDesc,
EventBeanCopyMethod copyMethod,
TypeWidener[] wideners,
EventType eventType,
Attribute[] annotations)
{
UpdateDesc = updateDesc;
CopyMethod = copyMethod;
Wideners = wideners;
EventType = eventType;
Annotations = annotations;
}
public InternalEventRouterDesc GetValidatePreprocessing(EventType eventType, UpdateDesc desc, Attribute[] annotations)
{
if (Log.IsDebugEnabled)
{
Log.Debug("Validating route preprocessing for type '" + eventType.Name + "'");
}
if (!(eventType is EventTypeSPI))
{
throw new ExprValidationException("Update statements require the event type to implement the " + typeof(EventTypeSPI) + " interface");
}
var eventTypeSPI = (EventTypeSPI)eventType;
var wideners = new TypeWidener[desc.Assignments.Count];
var properties = new List <String>();
for (int i = 0; i < desc.Assignments.Count; i++)
{
var xxx = desc.Assignments[i];
var assignmentPair = ExprNodeUtility.CheckGetAssignmentToProp(xxx.Expression);
if (assignmentPair == null)
{
throw new ExprValidationException("Missing property assignment expression in assignment number " + i);
}
var writableProperty = eventTypeSPI.GetWritableProperty(assignmentPair.First);
if (writableProperty == null)
{
throw new ExprValidationException("Property '" + assignmentPair.First + "' is not available for write access");
}
wideners[i] = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(assignmentPair.Second),
assignmentPair.Second.ExprEvaluator.ReturnType,
writableProperty.PropertyType,
assignmentPair.First);
properties.Add(assignmentPair.First);
}
// check copy-able
var copyMethod = eventTypeSPI.GetCopyMethod(properties.ToArray());
if (copyMethod == null)
{
throw new ExprValidationException("The update-clause requires the underlying event representation to support copy (via Serializable by default)");
}
return(new InternalEventRouterDesc(desc, copyMethod, wideners, eventType, annotations));
}
public void RemovePreprocessing(EventType eventType, UpdateDesc desc)
{
if (Log.IsInfoEnabled)
{
Log.Info("Removing route preprocessing for type '" + eventType.Name);
}
// remove all preprocessors for this type as well as any known child types
RemovePreprocessors(eventType);
_descriptors.Remove(desc);
if (_descriptors.IsEmpty())
{
_hasPreprocessing = false;
_preprocessors.Clear();
}
}
public void RemovePreprocessing(EventType eventType, UpdateDesc desc)
{
}
public InternalEventRouterDesc GetValidatePreprocessing(EventType eventType, UpdateDesc desc, Attribute[] annotations)
{
return(null);
}
public static InternalEventRouterDescForge GetValidatePreprocessing(
EventType eventType,
UpdateDesc desc,
Attribute[] annotations)
{
if (!(eventType is EventTypeSPI)) {
throw new ExprValidationException("Update statements require the event type to implement the " + typeof(EventTypeSPI) + " interface");
}
var eventTypeSPI = (EventTypeSPI) eventType;
var wideners = new List<TypeWidenerSPI>();
var properties = new List<string>();
var propertiesTouched = new List<string>();
var expressions = new List<ExprNode>();
var specialWriters = new List<InternalEventRouterWriterForge>();
for (var i = 0; i < desc.Assignments.Count; i++) {
var onSet = desc.Assignments[i];
var assignmentDesc = onSet.Validated;
try {
if (assignmentDesc is ExprAssignmentStraight assignment) {
var lhs = assignment.Lhs;
if (lhs is ExprAssignmentLHSIdent ident) {
var propertyName = ident.Ident;
var writableProperty = eventTypeSPI.GetWritableProperty(propertyName);
if (writableProperty == null) {
throw new ExprValidationException("Property '" + propertyName + "' is not available for write access");
}
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignment.Rhs),
assignment.Rhs.Forge.EvaluationType,
writableProperty.PropertyType,
propertyName,
false,
null,
null);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
properties.Add(propertyName);
propertiesTouched.Add(propertyName);
expressions.Add(assignment.Rhs);
wideners.Add(widener);
}
else if (lhs is ExprAssignmentLHSIdentWSubprop subprop) {
throw new ExprValidationException("Property '" + subprop.SubpropertyName + "' is not available for write access");
}
else if (lhs is ExprAssignmentLHSArrayElement arrayElement) {
var propertyName = lhs.Ident;
var writableProperty = eventTypeSPI.GetWritableProperty(propertyName);
if (writableProperty == null) {
throw new ExprValidationException("Property '" + propertyName + "' is not available for write access");
}
if (!writableProperty.PropertyType.IsArray) {
throw new ExprValidationException("Property '" + propertyName + "' type is not array");
}
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignment.Rhs),
assignment.Rhs.Forge.EvaluationType,
writableProperty.PropertyType.GetElementType(),
propertyName,
false,
null,
null);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
var special = new InternalEventRouterWriterArrayElementForge(
arrayElement.IndexExpression,
assignment.Rhs,
widener,
propertyName);
specialWriters.Add(special);
}
else {
throw new IllegalStateException("Unrecognized left hande side assignment " + lhs);
}
}
else if (assignmentDesc is ExprAssignmentCurly curly) {
var special = new InternalEventRouterWriterCurlyForge(curly.Expression);
specialWriters.Add(special);
}
else {
throw new IllegalStateException("Unrecognized assignment " + assignmentDesc);
}
}
catch (ExprValidationException ex) {
throw new ExprValidationException(
"Failed to validate assignment expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignmentDesc.OriginalExpression) +
"': " +
ex.Message,
ex);
}
}
// check copy-able
var copyMethod = eventTypeSPI.GetCopyMethodForge(propertiesTouched.ToArray());
if (copyMethod == null) {
throw new ExprValidationException(
"The update-clause requires the underlying event representation to support copy (via Serializable by default)");
}
return new InternalEventRouterDescForge(
copyMethod,
wideners.ToArray(),
eventType,
annotations,
desc.OptionalWhereClause,
properties.ToArray(),
expressions.ToArray(),
specialWriters.ToArray());
}
/// <summary>
/// 更新设备信息
/// </summary>
/// <param name="device_id"></param>
/// <param name="result"></param>
public void UpdateDevice(string device_id, string title, string desc, IUpdateDeviceResult result)
{
// client.Authenticator = new HttpBasicAuthenticator(username, password);
var request = new RestRequest("devices/{device_id}", Method.PUT);
request.AddUrlSegment("device_id", device_id); // replaces matching token in request.Resource
// add parameters for all properties on an object
//request.AddObject(object);
// or just whitelisted properties
//request.AddObject(object, "PersonId", "Name", ...);
// easily add HTTP Headers
request.AddHeader("api-key", "VtaeS4yK3Fk6xiOljgw69lYcH9k=");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
string[] keys = null;
string[] values = null;
if (!string.IsNullOrEmpty(title) && !string.IsNullOrEmpty(desc))
{
UpdateDevice updateDevice = new Entity.UpdateDevice();
updateDevice.title = title;
updateDevice.desc = desc;
keys = new string[] { "title", "desc" };
values = new string[] { title, desc };
request.AddJsonBody(updateDevice);
}
else if (!string.IsNullOrEmpty(title))
{
UpdateTitle updateTitle = new Entity.UpdateTitle();
updateTitle.title = title;
keys = new string[] { "title" };
values = new string[] { title };
request.AddJsonBody(updateTitle);
}
else if (!string.IsNullOrEmpty(desc))
{
UpdateDesc updateDesc = new UpdateDesc();
updateDesc.desc = desc;
keys = new string[] { "desc" };
values = new string[] { desc };
request.AddJsonBody(updateDesc);
}
IRestResponse response = client.Execute(request);
var content = response.Content; // raw content as string
if (response.ResponseStatus == ResponseStatus.Completed)
{
UpdateResponse updateResponse = JsonHelper.DeserializeJsonToObject <UpdateResponse>(content);
if (updateResponse.error.Equals("succ"))
{
DeviceDataDao.Instance.Update(device_id, keys, values);
result.OnSuccess("更新成功");
}
else
{
result.OnFailure(updateResponse.error);
}
}
else
{
result.OnFailure("更新设备信息失败");
}
}
public static InternalEventRouterDescForge GetValidatePreprocessing(
EventType eventType,
UpdateDesc desc,
Attribute[] annotations)
{
if (!(eventType is EventTypeSPI)) {
throw new ExprValidationException(
"Update statements require the event type to implement the " + typeof(EventTypeSPI) + " interface");
}
var eventTypeSPI = (EventTypeSPI) eventType;
var size = desc.Assignments.Count;
var wideners = new TypeWidenerSPI[size];
var properties = new string[size];
var expressions = new ExprNode[size];
for (var i = 0; i < size; i++) {
var onSet = desc.Assignments[i];
var assignmentPair = ExprNodeUtilityValidate.CheckGetAssignmentToProp(onSet.Expression);
if (assignmentPair == null) {
throw new ExprValidationException(
"Missing property assignment expression in assignment number " + i);
}
properties[i] = assignmentPair.First;
expressions[i] = assignmentPair.Second;
var writableProperty = eventTypeSPI.GetWritableProperty(assignmentPair.First);
if (writableProperty == null) {
throw new ExprValidationException(
"Property '" + assignmentPair.First + "' is not available for write access");
}
try {
wideners[i] = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignmentPair.Second),
assignmentPair.Second.Forge.EvaluationType,
writableProperty.PropertyType,
assignmentPair.First,
false,
null,
null);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
// check copy-able
var copyMethod = eventTypeSPI.GetCopyMethodForge(properties);
if (copyMethod == null) {
throw new ExprValidationException(
"The update-clause requires the underlying event representation to support copy (via Serializable by default)");
}
return new InternalEventRouterDescForge(
copyMethod,
wideners,
eventType,
annotations,
desc.OptionalWhereClause,
properties,
expressions);
}
