private void ProcessChangeComment(AAlterTypeCommand myAlterCommand,
ref RequestAlterEdgeType result)
{
var command = (AlterType_ChangeComment)myAlterCommand;
result.SetComment(command.NewComment);
}
private void ProcessRenameAttribute(AAlterTypeCommand myAlterCommand,
ref RequestAlterEdgeType result)
{
var command = (AlterType_RenameAttribute)myAlterCommand;
result.RenameAttribute(command.OldName, command.NewName);
}
/// <summary>
/// Creates a new pipelineable alter edge type request
/// </summary>
/// <param name="myRequest">The alter edge type request</param>
/// <param name="mySecurity">The security token of the request initiator</param>
/// <param name="myTransactionToken">The myOutgoingEdgeVertex transaction token</param>
public PipelineableAlterEdgeTypeRequest(RequestAlterEdgeType myRequest,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
: base(mySecurityToken, myTransactionToken)
{
_request = myRequest;
}
private void ProcessAlterCommand(AAlterTypeCommand myAlterCommand, ref RequestAlterEdgeType result)
{
switch (myAlterCommand.AlterType)
{
case TypesOfAlterCmd.AddAttribute:
ProcessAddAttribute(myAlterCommand, ref result);
break;
case TypesOfAlterCmd.DropAttribute:
ProcessDropAttribute(myAlterCommand, ref result);
break;
case TypesOfAlterCmd.RenameAttribute:
ProcessRenameAttribute(myAlterCommand, ref result);
break;
case TypesOfAlterCmd.RenameType:
ProcessRenameType(myAlterCommand, ref result);
break;
case TypesOfAlterCmd.ChangeComment:
ProcessChangeComment(myAlterCommand, ref result);
break;
default:
break;
}
}
private void ProcessDropAttribute(AAlterTypeCommand myAlterCommand,
ref RequestAlterEdgeType result)
{
var command = (AlterType_DropAttributes)myAlterCommand;
foreach (var aAttribute in command.ListOfAttributes)
{
result.RemoveUnknownAttribute(aAttribute);
}
}
internal ServiceAlterEdgeChangeset(RequestAlterEdgeType myRequestAlterEdgeType)
{
this.NewTypeName = myRequestAlterEdgeType.AlteredTypeName;
this.Comment = myRequestAlterEdgeType.AlteredComment;
this.ToBeAddedProperties = (myRequestAlterEdgeType.ToBeAddedProperties == null)
? null : myRequestAlterEdgeType.ToBeAddedProperties.Select(x => new ServicePropertyPredefinition(x)).ToArray();
this.ToBeRemovedProperties = (myRequestAlterEdgeType.ToBeRemovedProperties == null)
? null : myRequestAlterEdgeType.ToBeRemovedProperties.ToArray();
this.ToBeRenamedProperties = myRequestAlterEdgeType.ToBeRenamedProperties;
}
public static RequestAlterEdgeType MakeRequestAlterEdgeType(ServiceEdgeType myEdgeType, ServiceAlterEdgeChangeset myChangeset)
{
var Request = new RequestAlterEdgeType(myEdgeType.Name);
#region Add Attributes
if (myChangeset.ToBeAddedProperties != null)
{
foreach (var toAdd in myChangeset.ToBeAddedProperties)
{
Request.AddProperty(toAdd.ToPropertyPredefinition());
}
}
#endregion
#region Remove Attributes
if (myChangeset.ToBeRemovedProperties != null)
{
foreach (var toDel in myChangeset.ToBeRemovedProperties)
{
Request.RemoveProperty(toDel);
}
}
#endregion
#region Rename Task
if (myChangeset.ToBeRenamedProperties != null)
{
foreach (var item in myChangeset.ToBeRenamedProperties)
{
Request.RenameAttribute(item.Key, item.Value);
}
}
#endregion
if (myChangeset.Comment != null)
{
Request.SetComment(myChangeset.Comment);
}
if (myChangeset.NewTypeName != null)
{
Request.RenameType(myChangeset.NewTypeName);
}
//todo add unknown attribute
return(Request);
}
private void ProcessAddAttribute(AAlterTypeCommand myAlterCommand,
ref RequestAlterEdgeType result)
{
var command = (AlterEdgeType_AddAttributes)myAlterCommand;
if (command.ListOfAttributes != null && command.ListOfAttributes.Count > 0)
{
foreach (var aAttribute in command.ListOfAttributes)
{
result.AddUnknownAttribute(GenerateUnknownAttribute(aAttribute));
}
}
}
private RequestAlterEdgeType CreateNewRequest(IGraphDB myGraphDB,
GQLPluginManager myPluginManager,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
RequestAlterEdgeType result = new RequestAlterEdgeType(_TypeName);
foreach (var aAlterCommand in _AlterTypeCommand)
{
ProcessAlterCommand(aAlterCommand, ref result);
}
return(result);
}
public TResult AlterEdgeType <TResult>(SecurityToken mySecurityToken,
Int64 myTransactionToken,
RequestAlterEdgeType myRequestAlterEdgeType,
Converter.AlterEdgeTypeResultConverter <TResult> myOutputconverter)
{
var executedRequest =
_requestManager
.SynchronExecution(
new PipelineableAlterEdgeTypeRequest(myRequestAlterEdgeType,
mySecurityToken,
myTransactionToken));
return(((PipelineableAlterEdgeTypeRequest)executedRequest)
.GenerateRequestResult(myOutputconverter));
}
public TResult AlterEdgeType <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestAlterEdgeType myRequestAlterEdgeType, Converter.AlterEdgeTypeResultConverter <TResult> myOutputconverter)
{
return(_iGraphDB.AlterEdgeType <TResult>(
mySecurityToken,
myTransactionToken,
myRequestAlterEdgeType,
myOutputconverter));
}
public TResult AlterEdgeType <TResult>(SecurityToken mySecurityToken, Int64 myTransactionToken, RequestAlterEdgeType myRequestAlterEdgeType, Converter.AlterEdgeTypeResultConverter <TResult> myOutputconverter)
{
throw new NotImplementedException();
}
public override IEdgeType AlterType(IRequestAlterType myAlterTypeRequest,
Int64 myTransactionToken,
SecurityToken mySecurityToken,
out RequestUpdate myUpdateRequest)
{
CheckRequestType(myAlterTypeRequest);
RequestAlterEdgeType myRequest = myAlterTypeRequest as RequestAlterEdgeType;
var edgeType = _TypeManager.GetType(myRequest.TypeName,
myTransactionToken,
mySecurityToken);
#region check to be added
if (myRequest.ToBeAddedUnknownAttributes != null)
{
var toBeConverted = myRequest.ToBeAddedUnknownAttributes.ToArray();
foreach (var unknown in toBeConverted)
{
if (_baseTypeManager.IsBaseType(unknown.AttributeType))
{
var prop = ConvertUnknownToProperty(unknown);
myRequest.AddProperty(prop);
}
else
{
throw new InvalidAttributeTypeException(unknown.AttributeName,
unknown.AttributeType,
"This type is an invalid attribute type for an edge type!");
}
}
myRequest.ResetUnknown();
}
#endregion
#region check to be removed
if (myRequest.ToBeRemovedUnknownAttributes != null)
{
foreach (var unknownProp in myRequest.ToBeRemovedUnknownAttributes)
{
var attrDef = edgeType.GetAttributeDefinition(unknownProp);
if (attrDef == null)
{
throw new AttributeDoesNotExistException(unknownProp, edgeType.Name);
}
switch (attrDef.Kind)
{
case AttributeType.Property:
myRequest.RemoveProperty(unknownProp);
break;
case AttributeType.OutgoingEdge:
throw new Exception("Invalid AttributeType [OutgoingEdge] in alter type request!");
case AttributeType.IncomingEdge:
throw new Exception("Invalid AttributeType [IncomingEdge] in alter type request!");
case AttributeType.BinaryProperty:
throw new Exception("Invalid AttributeType [BinaryProperty] in alter type request!");
default:
throw new Exception("The enumeration AttributeType was changed, but not this switch statement.");
}
}
myRequest.ClearToBeRemovedUnknownAttributes();
}
#endregion
#region check attributes to be defined
if (myRequest.ToBeDefinedAttributes != null)
{
foreach (var unknownProp in myRequest.ToBeDefinedAttributes)
{
var toBeDefined = myRequest.ToBeDefinedAttributes.ToArray();
foreach (var unknown in toBeDefined)
{
if (BinaryPropertyPredefinition.TypeName.Equals(unknown.AttributeType))
{
throw new InvalidDefineAttributeTypeException(BinaryPropertyPredefinition.TypeName, edgeType.Name);
}
else if (unknown.AttributeType.Contains(IncomingEdgePredefinition.TypeSeparator))
{
throw new InvalidDefineAttributeTypeException("incoming edge", edgeType.Name);
}
else if (!_baseTypeManager.IsBaseType(unknown.AttributeType))
{
throw new InvalidDefineAttributeTypeException("user defined", edgeType.Name);
}
}
}
}
#endregion
#region check attributes to be undefined
if (myRequest.ToBeUndefinedAttributes != null)
{
foreach (var attr in myRequest.ToBeUndefinedAttributes)
{
var attrDef = edgeType.GetAttributeDefinition(attr);
if (attrDef == null)
{
throw new AttributeDoesNotExistException(attr);
}
switch (attrDef.Kind)
{
case AttributeType.Property:
break;
case AttributeType.OutgoingEdge:
throw new InvalidUndefineAttributeTypeException("Outgoing Edge", edgeType.Name);
case AttributeType.IncomingEdge:
throw new InvalidUndefineAttributeTypeException("Incoming Edge", edgeType.Name);
case AttributeType.BinaryProperty:
throw new InvalidUndefineAttributeTypeException(BinaryPropertyPredefinition.TypeName, edgeType.Name);
default:
throw new Exception("The enumeration AttributeType was changed, but not this switch statement.");
}
}
}
#endregion
#region checks
CallCheckFunctions(myAlterTypeRequest, edgeType, myTransactionToken, mySecurityToken);
#endregion
myUpdateRequest = new RequestUpdate();
return(null);
}
