private void OnTransferCommand(UInt160 tokenHash, UInt160 to, decimal amount, UInt160 from = null, string data = null, UInt160[] signersAccounts = null)
{
var snapshot = NeoSystem.StoreView;
var asset = new AssetDescriptor(snapshot, NeoSystem.Settings, tokenHash);
var value = new BigDecimal(amount, asset.Decimals);
if (NoWallet())
{
return;
}
Transaction tx;
try
{
tx = CurrentWallet.MakeTransaction(snapshot, new[]
{
new TransferOutput
{
AssetId = tokenHash,
Value = value,
ScriptHash = to,
Data = data
}
}, from: from, cosigners: signersAccounts?.Select(p => new Signer
{
// default access for transfers should be valid only for first invocation
Scopes = WitnessScope.CalledByEntry,
Account = p
})
.ToArray() ?? Array.Empty <Signer>());
}
catch (InvalidOperationException e)
{
ConsoleHelper.Error(GetExceptionMessage(e));
return;
}
if (!ReadUserInput("Relay tx(no|yes)").IsYes())
{
return;
}
SignAndSendTx(snapshot, tx);
}
private static Block CreateDummyBlock(StoreView snapshot)
{
var currentBlock = snapshot.Blocks[snapshot.CurrentBlockHash];
return(new Block
{
Version = 0,
PrevHash = snapshot.CurrentBlockHash,
MerkleRoot = new UInt256(),
Timestamp = currentBlock.Timestamp + Blockchain.MillisecondsPerBlock,
Index = snapshot.Height + 1,
NextConsensus = currentBlock.NextConsensus,
Witness = new Witness
{
InvocationScript = Array.Empty <byte>(),
VerificationScript = Array.Empty <byte>()
},
ConsensusData = new ConsensusData(),
Transactions = new Transaction[0]
});
}
private static bool GetLinqExpressionsBuiltWithIsInterpretingOnly()
{
return(!(bool)typeof(LambdaExpression).GetMethod("get_CanCompileToIL").Invoke(null, Array.Empty <object>()));
}
public Assembly[] ReflectionOnlyGetAssemblies() => Array.Empty <Assembly>();
public ZINTERSTORE(Key destination, IReadOnlyList <Key> keys, Aggregation aggregation = Aggregation.Sum)
: this(destination, keys, Array.Empty <double>(), aggregation)
{
}
private static List <string> GetResultColumns(HbmReturnProperty returnPropertySchema)
{
List <string> allResultColumns = new List <string>();
String column = Unquote(returnPropertySchema.column);
if (column != null)
{
allResultColumns.Add(column);
}
foreach (HbmReturnColumn returnColumnSchema in returnPropertySchema.returncolumn ?? Array.Empty <HbmReturnColumn>())
{
allResultColumns.Add(Unquote(returnColumnSchema.name));
}
return(allResultColumns);
}
private IDictionary <string, string[]> BindPropertyResults(string alias, HbmReturnDiscriminator discriminatorSchema,
HbmReturnProperty[] returnProperties, PersistentClass pc)
{
Dictionary <string, string[]> propertyresults = new Dictionary <string, string[]>();
// maybe a concrete SQLpropertyresult type, but Map is exactly what is required at the moment
if (discriminatorSchema != null)
{
propertyresults["class"] = GetResultColumns(discriminatorSchema).ToArray();
}
List <HbmReturnProperty> properties = new List <HbmReturnProperty>();
List <string> propertyNames = new List <string>();
foreach (HbmReturnProperty returnPropertySchema in returnProperties ?? Array.Empty <HbmReturnProperty>())
{
string name = returnPropertySchema.name;
if (pc == null || name.IndexOf('.') == -1)
{
//if dotted and not load-collection nor return-join
//regular property
properties.Add(returnPropertySchema);
propertyNames.Add(name);
}
else
{
// Reorder properties
// 1. get the parent property
// 2. list all the properties following the expected one in the parent property
// 3. calculate the lowest index and insert the property
int dotIndex = name.LastIndexOf('.');
string reducedName = name.Substring(0, dotIndex);
IValue value = pc.GetRecursiveProperty(reducedName).Value;
IEnumerable <Mapping.Property> parentPropIter;
if (value is Component)
{
Component comp = (Component)value;
parentPropIter = comp.PropertyIterator;
}
else if (value is ToOne)
{
ToOne toOne = (ToOne)value;
PersistentClass referencedPc = mappings.GetClass(toOne.ReferencedEntityName);
if (toOne.ReferencedPropertyName != null)
{
try
{
parentPropIter =
((Component)referencedPc.GetRecursiveProperty(toOne.ReferencedPropertyName).Value).PropertyIterator;
}
catch (InvalidCastException e)
{
throw new MappingException("dotted notation reference neither a component nor a many/one to one", e);
}
}
else
{
try
{
parentPropIter = ((Component)referencedPc.IdentifierProperty.Value).PropertyIterator;
}
catch (InvalidCastException e)
{
throw new MappingException("dotted notation reference neither a component nor a many/one to one", e);
}
}
}
else
{
throw new MappingException("dotted notation reference neither a component nor a many/one to one");
}
bool hasFollowers = false;
List <string> followers = new List <string>();
foreach (Mapping.Property prop in parentPropIter)
{
string currentPropertyName = prop.Name;
string currentName = reducedName + '.' + currentPropertyName;
if (hasFollowers)
{
followers.Add(currentName);
}
if (name.Equals(currentName))
{
hasFollowers = true;
}
}
int index = propertyNames.Count;
int followersSize = followers.Count;
for (int loop = 0; loop < followersSize; loop++)
{
string follower = followers[loop];
int currentIndex = GetIndexOfFirstMatchingProperty(propertyNames, follower);
index = currentIndex != -1 && currentIndex < index ? currentIndex : index;
}
propertyNames.Insert(index, name);
properties.Insert(index, returnPropertySchema);
}
}
var uniqueReturnProperty = new HashSet <string>();
foreach (HbmReturnProperty returnPropertySchema in properties)
{
string name = returnPropertySchema.name;
if ("class".Equals(name))
{
throw new MappingException(
"class is not a valid property name to use in a <return-property>, use <return-discriminator> instead"
);
}
//TODO: validate existing of property with the chosen name. (secondpass )
List <string> allResultColumns = GetResultColumns(returnPropertySchema);
if (allResultColumns.Count == 0)
{
throw new MappingException(
"return-property for alias " + alias +
" must specify at least one column or return-column name"
);
}
if (uniqueReturnProperty.Contains(name))
{
throw new MappingException(
"duplicate return-property for property " + name +
" on alias " + alias
);
}
uniqueReturnProperty.Add(name);
// the issue here is that for <return-join/> representing an entity collection,
// the collection element values (the property values of the associated entity)
// are represented as 'element.{propertyname}'. Thus the StringHelper.root()
// here puts everything under 'element' (which additionally has significant
// meaning). Probably what we need to do is to something like this instead:
// String root = StringHelper.root( name );
// String key = root; // by default
// if ( !root.equals( name ) ) {
// // we had a dot
// if ( !root.equals( alias ) {
// // the root does not apply to the specific alias
// if ( "elements".equals( root ) {
// // we specifically have a <return-join/> representing an entity collection
// // and this <return-property/> is one of that entity's properties
// key = name;
// }
// }
// }
// but I am not clear enough on the intended purpose of this code block, especially
// in relation to the "Reorder properties" code block above...
// String key = StringHelper.root( name );
string key = name;
string[] intermediateResults;
if (!propertyresults.TryGetValue(key, out intermediateResults))
{
propertyresults[key] = allResultColumns.ToArray();
}
else
{
throw new NotImplementedException();
// 2013-02-24: In 89994bc113e1bb35bf6bcd0b7408d08340bfbccd, 2008-05-29, the intermediateResults
// variable was changed from ArrayList to string[]. The following code line was there before.
// Since an array cannot be modified, it seems this code line has never been hit since then.
// While working on NH-3345, I'm adding an ambigous overload for AddAll(), and I don't want to
// try to understand this code right now, so comment it out instead. /Oskar
//ArrayHelper.AddAll(intermediateResults, allResultColumns); // TODO: intermediateResults not used after this
}
}
Dictionary <string, string[]> newPropertyResults = new Dictionary <string, string[]>();
foreach (KeyValuePair <string, string[]> entry in propertyresults)
{
newPropertyResults[entry.Key] = entry.Value;
}
return(newPropertyResults.Count == 0 ? (IDictionary <string, string[]>)CollectionHelper.EmptyDictionary <string, string[]>() : newPropertyResults);
}
