public bool IsGameContinuation(Protocols.UciGameData data,
out List<Move> extra_moves)
{
Debug.Assert(data != null);
extra_moves = null;
if (m_initial_position != data.m_initial_position
|| m_moves.Count > (data.m_moves == null ? 0 : data.m_moves.Count))
{
return false;
}
for (int i = 0; i < m_moves.Count; ++i)
{
if (NotationHelper.ToCoordinateNotation(m_moves[i])
!= data.m_moves[i])
{
return false;
}
}
if (data.m_moves != null && data.m_moves.Count > m_moves.Count)
{
extra_moves = new List<Move>(data.m_moves.Count - m_moves.Count);
for (int i = m_moves.Count; i < data.m_moves.Count; ++i)
{
extra_moves.Add(Move.MakeFromCoordinates(data.m_moves[i]));
}
}
return true;
}
public RejectRule(FireWallChains chain, string networkInterface, Protocols protocol, ICMPTypes? icmpType, IPAddress source, IPAddress sourceNetworkMask,
FirewallPort sourcePort, IPAddress destination, IPAddress destinationNetworkMask, FirewallPort destinationPort,
ConnectionStateTypes[] connectionStates,string note,RejectOptions rejectWith) :
base(chain,networkInterface, protocol, icmpType, source, sourceNetworkMask, sourcePort, destination, destinationNetworkMask, destinationPort, connectionStates,note)
{
_rejectWith = rejectWith;
}
public CommandSetPosition(Protocols.UciGameData data)
{
if (data == null)
{
throw new ArgumentNullException();
}
m_uci_data = data;
}
public Tunnel(bool is_server, ulong remote_userid, Service service, Protocols protocols, ushort server_port)
{
_remote_userid = remote_userid;
_is_server = is_server;
_service = service;
_server_port = server_port;
_protocols = protocols;
state = TunnelState.Initial;
}
/// <summary>
/// Returns signed cookies that grants universal access to private content until a given date.
/// </summary>
/// <param name="protocol">The protocol used to access content using signed cookies.</param>
/// <param name="distributionDomain">The domain name of the distribution.</param>
/// <param name="resourcePath">The path for the resource.</param>
/// <param name="privateKey">The private key file. RSA private key (.pem) are supported.</param>
/// <param name="keyPairId">The key pair id corresponding to the private key file given.</param>
/// <param name="expiresOn">The expiration date till which content can be accessed using the generated cookies.</param>
/// <returns>The signed cookies.</returns>
public static CookiesForCannedPolicy GetCookiesForCannedPolicy(Protocols protocol,
string distributionDomain,
TextReader privateKey,
string resourcePath,
string keyPairId,
DateTime expiresOn)
{
string url = GenerateResourcePath(protocol, distributionDomain, resourcePath);
return GetCookiesForCannedPolicy(url, keyPairId, privateKey, expiresOn);
}
/// <summary>
/// Initializes a new instance of the Protocol class to be extended by derived types.
/// </summary>
/// <param name="connectionString">Connection string to be parsed.</param>
/// <param name="protocol">Derived protocol type.</param>
protected Protocol(string connectionString, Protocols protocol)
{
this.Type = protocol;
var fields = Parse(connectionString);
var properties = this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var property in properties.Where(property => property.Name != "Type" && fields.ContainsKey(property.Name)))
{
property.SetValue(this, fields[property.Name], null);
}
}
/// <summary>
/// Returns signed cookies that grants universal access to private content until a given date.
/// </summary>
/// <param name="protocol">The protocol used to access content using signed cookies.</param>
/// <param name="distributionDomain">The domain name of the distribution.</param>
/// <param name="resourcePath">The path for the resource.</param>
/// <param name="privateKey">The private key file. RSA private key (.pem) are supported.</param>
/// <param name="keyPairId">The key pair id corresponding to the private key file given.</param>
/// <param name="expiresOn">The expiration date till which content can be accessed using the generated cookies.</param>
/// <returns>The signed cookies.</returns>
public static CookiesForCannedPolicy GetCookiesForCannedPolicy(Protocols protocol,
string distributionDomain,
FileSystemInfo privateKey,
string resourcePath,
string keyPairId,
DateTime expiresOn)
{
using (var reader = new StreamReader(File.OpenRead(privateKey.FullName)))
{
return GetCookiesForCannedPolicy(protocol, distributionDomain, reader, resourcePath, keyPairId, expiresOn);
}
}
public LogRule(FireWallChains chain, string networkInterface, Protocols protocol, ICMPTypes? icmpType, IPAddress source, IPAddress sourceNetworkMask,
FirewallPort sourcePort, IPAddress destination, IPAddress destinationNetworkMask, FirewallPort destinationPort,
ConnectionStateTypes[] connectionStates,string note,LogLevels level,string logPrefix,bool logTcpOptions,bool logTcpSequence,bool logIPOptions) :
base(chain,networkInterface, protocol, icmpType, source, sourceNetworkMask, sourcePort, destination, destinationNetworkMask, destinationPort, connectionStates,note)
{
_logLevel = level;
_logPrefix = logPrefix;
_logTcpOptions = logTcpOptions;
_logTcpSequence = logTcpSequence;
_logIPOptions = logIPOptions;
if (_logPrefix != null)
{
if (_logPrefix.Length > 29)
throw new Exception("The log prefix " + _logPrefix + " is too long, it cannot exceed 29 characters.");
}
}
protected Protocols.Http.Request CreateRequest(Protocols.Http.Methods.Base method, Uri uri,
string contentType)
{
Protocols.Http.Request request;
MultisourcedStream fullStream;
long fullContentLength;
request = new Protocols.Http.Request(method, uri);
fullStream = MakeStream(out fullContentLength);
request.Headers.Add(new Protocols.Http.Message.ContentLengthHeader(fullContentLength));
request.Body.IsChunked = false;
request.Body.SendStream = fullStream;
return request;
}
public ULogRule(FireWallChains chain, string networkInterface, Protocols protocol, ICMPTypes? icmpType, IPAddress source, IPAddress sourceNetworkMask,
FirewallPort sourcePort, IPAddress destination, IPAddress destinationNetworkMask, FirewallPort destinationPort,
ConnectionStateTypes[] connectionStates,string note,byte logGroup,string prefix,uint bytesToCopy,ushort queueSize) :
base(chain,networkInterface, protocol, icmpType, source, sourceNetworkMask, sourcePort, destination, destinationNetworkMask, destinationPort, connectionStates,note)
{
_logGroup = logGroup;
_prefix = prefix;
_bytesToCopy = bytesToCopy;
_queueSize = queueSize;
if (_prefix != null)
{
if (_prefix.Length > 32)
throw new Exception("Unable to create ULog rule with a message prefix greater than 32 characters.");
}
if (_logGroup < 1 || _logGroup > 32)
throw new Exception("Unable to create ULog rule with a log group not from 1-32.");
if (_queueSize < 1)
throw new Exception("Unable to create a ULog rule with a queue size less than 1.");
}
public Protocols.ToolkitResultProtocol AcceptQuote(Protocols.Contracts.AcceptQuoteSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.AcceptQuoteSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.AcceptQuoteSetup(setupParam.QuoteIDNum);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.QuoteIDNum = setupParam.QuoteIDNum;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.AcceptDate = setupParam.AcceptDate;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.WipBin = setupParam.WipBin;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.UserName = setupParam.UserName;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
}
return new Protocols.ToolkitResultProtocol( toolkit.AcceptQuote(setup) );
}
/// <summary>
/// Initializes a new instance of the Protocol class to be extended by derived types.
/// </summary>
/// <param name="connectionString">Connection string to be parsed.</param>
/// <param name="reportFile">Report file in which the report details are contained.</param>
/// <param name="protocol">Derived protocol type.</param>
protected Protocol(string connectionString, Stream reportFile, Protocols protocol)
: this(connectionString, protocol)
{
this.ReportFile = reportFile;
// ToDo: Optimize this so large dump files will not be loaded into the memory before sending but streamed from the disk
// Not inside using(...) block to prevent file stream from getting closed
var zipStorer = ZipStorer.Open(reportFile, FileAccess.Read);
using (Stream zipItemStream = new MemoryStream())
{
var zipDirectory = zipStorer.ReadCentralDir();
foreach (var entry in zipDirectory)
{
if (Path.GetFileName(entry.FilenameInZip) == StoredItemFile.Exception)
{
zipItemStream.SetLength(0);
zipStorer.ExtractFile(entry, zipItemStream);
zipItemStream.Position = 0;
var deserializer = new XmlSerializer(typeof(SerializableException));
this.SerializableException = (SerializableException)deserializer.Deserialize(zipItemStream);
zipItemStream.Position = 0;
this.reportItems.Add(StoredItemType.Exception, XElement.Load(zipItemStream));
}
else if (Path.GetFileName(entry.FilenameInZip) == StoredItemFile.Report)
{
zipItemStream.SetLength(0);
zipStorer.ExtractFile(entry, zipItemStream);
zipItemStream.Position = 0;
var deserializer = new XmlSerializer(typeof(Report));
this.Report = (Report)deserializer.Deserialize(zipItemStream);
zipItemStream.Position = 0;
this.reportItems.Add(StoredItemType.Report, XElement.Load(zipItemStream));
}
}
}
this.ReportFile.Position = 0;
}
/// <summary>
/// Returns null if the custom settings file is not found so check for null object reference.
/// </summary>
internal List<string> ReadCustomDispatcherDestinationSettings(Protocols protocol)
{
// This generates a sample settings file for future reference
/*this.dispatcherDestinations.Add("Just testing this stuff.");
var serializer = new XmlSerializer(typeof(List<string>));
using (FileStream stream = new FileStream("DispatcherDestinations.xml", FileMode.Create))
{
serializer.Serialize(stream, this.dispatcherDestinations);
}*/
// Make sure that settings are red and cached only once during the object lifetime
if (this.dispatcherDestinations == null)
{
this.dispatcherDestinations = new List<string>();
var path = Path.Combine(Settings.NBugDirectory, "DispatcherDestinations.xml");
if (!File.Exists(path))
{
path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Docs\\ASFT\\Dev\\_Tools\\Settings\\DispatcherDestinations.xml");
if (!File.Exists(path))
{
return null;
}
}
var serializer = new XmlSerializer(typeof(List<string>));
using (var stream = new FileStream(path, FileMode.Open))
{
this.dispatcherDestinations = (List<string>)serializer.Deserialize(stream);
}
}
return (from destination in this.dispatcherDestinations
where Enum.Parse(typeof(Protocols), Protocol.Parse(destination)["Type"], true).Equals(protocol)
select destination).ToList();
}
public Protocols.ToolkitResultProtocol ApplyEco(Protocols.DepotRepair.ApplyEcoSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit toolkit = new FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit( session );
FChoice.Toolkits.Clarify.DepotRepair.ApplyEcoSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.DepotRepair.ApplyEcoSetup(setupParam.DemandDetailObjid, setupParam.EcoHeaderIDNum);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.DemandDetailObjid = setupParam.DemandDetailObjid;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.EcoHeaderIDNum = setupParam.EcoHeaderIDNum;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.UserName = setupParam.UserName;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.CreateDate = setupParam.CreateDate;
}
return new Protocols.ToolkitResultProtocol( toolkit.ApplyEco(setup) );
}
public Protocols.ToolkitResultProtocol UnrelateContractItemFromSitePart(Protocols.Contracts.UnrelateContractItemFromSitePartSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.UnrelateContractItemFromSitePartSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.UnrelateContractItemFromSitePartSetup(setupParam.ContractObjid, setupParam.PartNumber, setupParam.PartDomain, setupParam.PartRevision);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.ContractObjid = setupParam.ContractObjid;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.PartNumber = setupParam.PartNumber;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.PartDomain = setupParam.PartDomain;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.PartRevision = setupParam.PartRevision;
}
return new Protocols.ToolkitResultProtocol( toolkit.UnrelateContractItemFromSitePart(setup) );
}
protected Protocol(Protocols protocol)
{
this.Type = protocol;
}
public static bool IsZero(BinaryOpStorage /*!*/ equals, object self)
{
return(Protocols.IsEqual(equals, self, 0));
}
public static object Round(RubyContext /*!*/ context, object self)
{
double floatSelf = Protocols.ConvertToFloat(context, self);
return(FloatOps.Round(floatSelf));
}
public static bool Equals(RespondToStorage /*!*/ respondTo, BinaryOpStorage /*!*/ equals, IDictionary <object, object> /*!*/ self, object other)
{
return(Protocols.RespondTo(respondTo, other, "to_hash") && Protocols.IsEqual(equals, other, self));
}
public static MutableString /*!*/ GetMessage(RubyContext /*!*/ context, Exception /*!*/ self)
{
return(Protocols.AsString(context, GetMessage(self)));
}
public static object Truncate(RubyContext /*!*/ context, object self)
{
double floatSelf = Protocols.ConvertToFloat(context, self);
return(FloatOps.ToInt(floatSelf));
}
public static object Tagurize(ConversionStorage <MutableString> /*!*/ stringTryCast, RubyModule /*!*/ self, object arg)
{
var str = Protocols.TryCastToString(stringTryCast, arg);
return((str != null) ? MutableString.CreateMutable(str.Encoding).Append("tag:yaml.org,2002:").Append(str) : arg);
}
internal static FlowStyle ToYamlFlowStyle(object styleObj)
{
return(Protocols.IsTrue(styleObj) ? FlowStyle.Inline : FlowStyle.Block);
}
public static object ChangeDirectory(ConversionStorage <MutableString> /*!*/ toPath, BlockParam block, RubyClass /*!*/ self, object dir)
{
var d = Protocols.CastToPath(toPath, dir);
return(ChangeDirectory(self.Context.Platform, self.Context.DecodePath(d), d, block));
}
/// <summary>
///
/// </summary>
/// <param name="itemType"></param>
/// <param name="value"></param>
private void AddItem(ItemType itemType, object value)
{
if (value.ToString().Length == 0)
{
return;
}
switch (itemType)
{
case ItemType.IpAddress:
var ipAddresses = from ipAddress in IpAddresses where ipAddress.Text.ToUpper() == ((string)value).ToUpper() select ipAddress;
if (ipAddresses.Count() == 0)
{
IpAddress ipAddress = new IpAddress();
ipAddress.Text = (string)value;
IpAddresses.Add(ipAddress);
}
break;
case ItemType.HostName:
var hosts = from host in HostNames where host.ToUpper() == ((string)value).ToUpper() select host;
if (hosts.Count() == 0)
{
HostNames.Add((string)value);
}
break;
case ItemType.Port:
var ports = from port in Ports where port == (int)value select port;
if (ports.Count() == 0)
{
Ports.Add((int)value);
}
break;
case ItemType.Protocol:
var protocols = from protocol in Protocols where protocol.ToUpper() == ((string)value).ToUpper() select protocol;
if (protocols.Count() == 0)
{
Protocols.Add(((string)value).ToUpper());
}
break;
case ItemType.Service:
var services = from service in Services where service.ToUpper() == ((string)value).ToUpper() select service;
if (services.Count() == 0)
{
Services.Add((string)value);
}
break;
case ItemType.State:
var states = from state in States where state.ToUpper() == ((string)value).ToUpper() select state;
if (states.Count() == 0)
{
States.Add((string)value);
}
break;
case ItemType.Severities:
var severities = from severity in Severities where severity.ToUpper() == ((string)value).ToUpper() select severity;
if (severities.Count() == 0)
{
Severities.Add((string)value);
}
break;
case ItemType.PluginFamily:
var pluginFamilies = from pluginFamily in PluginFamilys where pluginFamily.ToUpper() == ((string)value).ToUpper() select pluginFamily;
if (pluginFamilies.Count() == 0)
{
PluginFamilys.Add((string)value);
}
break;
case ItemType.PluginId:
var pluginIds = from pluginId in PluginIds where pluginId.ToString().ToUpper() == ((string)value).ToUpper() select pluginId;
if (pluginIds.Count() == 0)
{
PluginIds.Add(int.Parse(value.ToString()));
}
break;
case ItemType.PluginName:
var pluginNames = from pluginName in PluginNames where pluginName.ToUpper() == ((string)value).ToUpper() select pluginName;
if (pluginNames.Count() == 0)
{
PluginNames.Add((string)value);
}
break;
case ItemType.Product:
var products = from product in Products where product.ToUpper() == ((string)value).ToUpper() select product;
if (products.Count() == 0)
{
Products.Add((string)value);
}
break;
case ItemType.Versions:
var versions = from version in Versions where version.ToUpper() == ((string)value).ToUpper() select version;
if (versions.Count() == 0)
{
Versions.Add((string)value);
}
break;
case ItemType.ExploitAvailable:
var exploitAvailable = from e in ExploitAvailable where e.ToUpper() == ((string)value).ToUpper() select e;
if (exploitAvailable.Count() == 0)
{
ExploitAvailable.Add((string)value);
}
break;
default:
break;
}
}
public static RubyDir /*!*/ Open(ConversionStorage <MutableString> /*!*/ toPath, RubyClass /*!*/ self, object dirname)
{
return(new RubyDir(self, Protocols.CastToPath(toPath, dirname)));
}
public static object ForEach(ConversionStorage <MutableString> /*!*/ toPath, BlockParam block, RubyClass /*!*/ self, object dirname)
{
return(new RubyDir(self, Protocols.CastToPath(toPath, dirname)).EnumerateEntries(self.Context, block, null));
}
public static RubyArray /*!*/ GetEntries(ConversionStorage <MutableString> /*!*/ toPath, RubyClass /*!*/ self, object dirname)
{
return(new RubyDir(self, Protocols.CastToPath(toPath, dirname)).GetEntries(self.Context));
}
public Protocols.ToolkitResultProtocol CreateContractLineItem(Protocols.Contracts.CreateContractLineItemSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.CreateContractLineItemSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.CreateContractLineItemSetup(setupParam.ContractIDNum, setupParam.PartNumber, setupParam.PartDomain, setupParam.PartRevision, setupParam.Quantity, setupParam.PriceSchedule, setupParam.ParentLineItemObjid);
break;
case 1:
setup = new FChoice.Toolkits.Clarify.Contracts.CreateContractLineItemSetup(setupParam.ContractIDNum, setupParam.PartNumber, setupParam.PartDomain, setupParam.PartRevision, setupParam.PriceSchedule, setupParam.SerialNumber, setupParam.ParentLineItemObjid);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.ContractIDNum = setupParam.ContractIDNum;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.UserName = setupParam.UserName;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.CreateDate = setupParam.CreateDate;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.StartDate = setupParam.StartDate;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.EndDate = setupParam.EndDate;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.PartNumber = setupParam.PartNumber;
}
if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
{
setup.PartDomain = setupParam.PartDomain;
}
if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
{
setup.PartRevision = setupParam.PartRevision;
}
if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
{
setup.Quantity = setupParam.Quantity;
}
if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
{
setup.PriceSchedule = setupParam.PriceSchedule;
}
if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
{
setup.OverridePrice = setupParam.OverridePrice;
}
if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
{
setup.UnitsUsed = setupParam.UnitsUsed;
}
if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
{
setup.SerialNumber = setupParam.SerialNumber;
}
if( Global.IsPropertyDirty(8192, setupParam.DirtyFieldFlags) )
{
setup.IsTaxable = setupParam.IsTaxable;
}
if( Global.IsPropertyDirty(16384, setupParam.DirtyFieldFlags) )
{
setup.AutoInstall = setupParam.AutoInstall;
}
if( Global.IsPropertyDirty(32768, setupParam.DirtyFieldFlags) )
{
setup.Comments = setupParam.Comments;
}
if( Global.IsPropertyDirty(65536, setupParam.DirtyFieldFlags) )
{
setup.QuotedSiteIDNum = setupParam.QuotedSiteIDNum;
}
if( Global.IsPropertyDirty(131072, setupParam.DirtyFieldFlags) )
{
setup.ServicedAtSiteIDNum = setupParam.ServicedAtSiteIDNum;
}
if( Global.IsPropertyDirty(262144, setupParam.DirtyFieldFlags) )
{
setup.ParentLineItemObjid = setupParam.ParentLineItemObjid;
}
if( Global.IsPropertyDirty(524288, setupParam.DirtyFieldFlags) )
{
setup.POIDNum = setupParam.POIDNum;
}
if( Global.IsPropertyDirty(1048576, setupParam.DirtyFieldFlags) )
{
foreach(Protocols.AdditionalFieldProtocol field in setupParam.AdditionalFields){setup.AdditionalFields.Append( field.FieldName, field.FieldType, field.FieldValue);}
}
return new Protocols.ToolkitResultProtocol( toolkit.CreateContractLineItem(setup) );
}
private static RubyEncoding ToEncoding(ConversionStorage <MutableString> /*!*/ toStr, object obj)
{
return((obj == null) ? null :
obj as RubyEncoding ??
RubyEncoding.GetRubyEncoding(Protocols.CastToString(toStr, obj).ToString())); // TODO: ToString
}
public static object Step(
BinaryOpStorage /*!*/ equals,
BinaryOpStorage /*!*/ greaterThanStorage,
BinaryOpStorage /*!*/ lessThanStorage,
BinaryOpStorage /*!*/ addStorage,
ConversionStorage <double> /*!*/ tofStorage,
BlockParam block, object self, object limit, [Optional] object step)
{
if (step == Missing.Value)
{
step = ClrInteger.One;
}
if (self is double || limit is double || step is double)
{
var site = tofStorage.GetSite(ConvertToFAction.Make(tofStorage.Context));
// At least one of the arguments is double so convert all to double and run the Float version of Step
double floatSelf = self is double?(double)self : site.Target(site, self);
double floatLimit = limit is double?(double)self : site.Target(site, limit);
double floatStep = step is double?(double)self : site.Target(site, step);
return(Step(block, floatSelf, floatLimit, floatStep));
}
else
{
#region The generic step algorithm:
// current = self
// if step is postive then
// while current < limit do
// yield(current)
// current = current + step
// end
// else
// while current > limit do
// yield(current)
// current = current + step
// end
// return self
#endregion
bool isStepZero = Protocols.IsEqual(equals, step, 0);
if (isStepZero)
{
throw RubyExceptions.CreateArgumentError("step can't be 0");
}
var greaterThan = greaterThanStorage.GetCallSite(">");
bool isStepPositive = RubyOps.IsTrue(greaterThan.Target(greaterThan, step, 0));
var compare = isStepPositive ? greaterThan : lessThanStorage.GetCallSite("<");
object current = self;
while (!RubyOps.IsTrue(compare.Target(compare, current, limit)))
{
object result;
if (YieldStep(block, current, out result))
{
return(result);
}
var add = addStorage.GetCallSite("+");
current = add.Target(add, current, step);
}
return(self);
}
}
public static object Floor(RubyContext /*!*/ context, object self)
{
return(FloatOps.Floor(Protocols.ConvertToFloat(context, self)));
}
public static bool IsZero(RubyContext /*!*/ context, object self)
{
return(Protocols.IsEqual(context, self, 0));
}
public Protocols.ToolkitResultProtocol UpdateDepotRepairMaterial(Protocols.DepotRepair.UpdateDepotRepairMaterialSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit toolkit = new FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit( session );
FChoice.Toolkits.Clarify.DepotRepair.UpdateDepotRepairMaterialSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.DepotRepair.UpdateDepotRepairMaterialSetup(setupParam.MaterialLogObjid, setupParam.Disposition);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.MaterialLogObjid = setupParam.MaterialLogObjid;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.RepairCode = setupParam.RepairCode;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.FailureCode = setupParam.FailureCode;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.PartRevisionObjid = setupParam.PartRevisionObjid;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.IsBillable = setupParam.IsBillable;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.BillTo = setupParam.BillTo;
}
if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
{
setup.WorkCenter = setupParam.WorkCenter;
}
if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
{
setup.Disposition = setupParam.Disposition;
}
if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
{
setup.ReferenceDesignator = setupParam.ReferenceDesignator;
}
if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
{
setup.Notes = setupParam.Notes;
}
if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
{
setup.TransactionID = setupParam.TransactionID;
}
if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
{
setup.UserName = setupParam.UserName;
}
if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
{
setup.CreateDate = setupParam.CreateDate;
}
return new Protocols.ToolkitResultProtocol( toolkit.UpdateDepotRepairMaterial(setup) );
}
public static object UnaryMinus(RubyContext /*!*/ context, object self)
{
return(Protocols.CoerceAndCall(context, 0, self, LibrarySites.Minus));
}
public Protocols.ToolkitResultProtocol UpdateEcoMaterialDetail(Protocols.DepotRepair.UpdateEcoMaterialDetailSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit toolkit = new FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit( session );
FChoice.Toolkits.Clarify.DepotRepair.UpdateEcoMaterialDetailSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.DepotRepair.UpdateEcoMaterialDetailSetup(setupParam.EcoDetailObjid, setupParam.PartRevisionObjid);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.EcoDetailObjid = setupParam.EcoDetailObjid;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.IsRequired = setupParam.IsRequired;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.Status = setupParam.Status;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.ElapsedTime = TimeSpan.FromSeconds(setupParam.ElapsedTime);
}
if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
{
setup.Location = setupParam.Location;
}
if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
{
setup.Description = setupParam.Description;
}
if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
{
setup.EcoHeaderIDNum = setupParam.EcoHeaderIDNum;
}
if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
{
setup.PartRevisionObjid = setupParam.PartRevisionObjid;
}
return new Protocols.ToolkitResultProtocol( toolkit.UpdateEcoMaterialDetail(setup) );
}
public static int SysWrite(BinaryOpStorage /*!*/ writeStorage, ConversionStorage <MutableString> /*!*/ tosConversion,
RubyContext /*!*/ context, RubyIO /*!*/ self, object obj)
{
return(SysWrite(writeStorage, tosConversion, context, self, Protocols.ConvertToString(tosConversion, obj)));
}
public static object UnaryMinus(BinaryOpStorage /*!*/ coercionStorage, BinaryOpStorage /*!*/ binaryOpSite, object self)
{
return(Protocols.CoerceAndApply(coercionStorage, binaryOpSite, "-", 0, self));
}
public static int WriteNoBlock(ConversionStorage <MutableString> /*!*/ tosConversion, RubyIO /*!*/ self, object obj)
{
return(Write(self, Protocols.ConvertToString(tosConversion, obj)));
}
public Protocols.ToolkitResultProtocol CreatePriceInstance(Protocols.Contracts.CreatePriceInstanceSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.CreatePriceInstanceSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.CreatePriceInstanceSetup(setupParam.PartNumber, setupParam.PartRevision, setupParam.PartDomain, setupParam.SupportProgram, setupParam.PriceProgram, setupParam.PriceType, setupParam.Quantity);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.PartNumber = setupParam.PartNumber;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.PartRevision = setupParam.PartRevision;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.PartDomain = setupParam.PartDomain;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.SupportProgram = setupParam.SupportProgram;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.PriceProgram = setupParam.PriceProgram;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.PriceType = setupParam.PriceType;
}
if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
{
setup.Quantity = setupParam.Quantity;
}
if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
{
setup.Price = setupParam.Price;
}
if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
{
setup.EffectiveDate = setupParam.EffectiveDate;
}
if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
{
setup.ExpireDate = setupParam.ExpireDate;
}
if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
{
foreach(Protocols.AdditionalFieldProtocol field in setupParam.AdditionalFields){setup.AdditionalFields.Append( field.FieldName, field.FieldType, field.FieldValue);}
}
return new Protocols.ToolkitResultProtocol( toolkit.CreatePriceInstance(setup) );
}
public Protocols.ToolkitResultProtocol UpdateEcoItem(Protocols.DepotRepair.UpdateEcoItemSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit toolkit = new FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit( session );
FChoice.Toolkits.Clarify.DepotRepair.UpdateEcoItemSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.DepotRepair.UpdateEcoItemSetup(setupParam.EcoItemObjid, setupParam.IsActive, setupParam.EcoHeaderIDNum);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.EcoItemObjid = setupParam.EcoItemObjid;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.AppliesTo = setupParam.AppliesTo;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.IsActive = setupParam.IsActive;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.EcoHeaderIDNum = setupParam.EcoHeaderIDNum;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.ApplyPartRevisionObjid = setupParam.ApplyPartRevisionObjid;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.ResultPartRevisionObjid = setupParam.ResultPartRevisionObjid;
}
return new Protocols.ToolkitResultProtocol( toolkit.UpdateEcoItem(setup) );
}
public Protocols.ToolkitResultProtocol DeleteSitePart(Protocols.Contracts.DeleteSitePartSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.DeleteSitePartSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.DeleteSitePartSetup(setupParam.SitePartObjid);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.SitePartObjid = setupParam.SitePartObjid;
}
return new Protocols.ToolkitResultProtocol( toolkit.DeleteSitePart(setup) );
}
private void ProtocolView_OnProtocolAddEvent(object sender, Protocols.ProtocolAddEvent e)
{
protocolView.LoadProtocolName(e.value + ": " + indexTest++);
}
public static void ImportConnectionsFromPortScan(ArrayList Hosts, Protocols Protocol)
{
foreach (ScanHost Host in Hosts)
{
Protocols finalProt = Protocols.NONE;
bool protOK = false;
TreeNode nNode = Node.AddNode(Node.Type.Connection, (string)Host.HostNameWithoutDomain);
Connection.Info nConI = new Connection.Info();
nConI.Inherit = new Connection.Info.Inheritance(nConI);
nConI.Name = Host.HostNameWithoutDomain;
nConI.Hostname = Host.HostName;
switch (Protocol)
{
case Protocols.SSH2:
if (Host.SSH)
{
finalProt = Protocols.SSH2;
protOK = true;
}
break;
case Protocols.Telnet:
if (Host.Telnet)
{
finalProt = Protocols.Telnet;
protOK = true;
}
break;
case Protocols.HTTP:
if (Host.HTTP)
{
finalProt = Protocols.HTTP;
protOK = true;
}
break;
case Protocols.HTTPS:
if (Host.HTTPS)
{
finalProt = Protocols.HTTPS;
protOK = true;
}
break;
case Protocols.Rlogin:
if (Host.Rlogin)
{
finalProt = Protocols.Rlogin;
protOK = true;
}
break;
case Protocols.Serial:
if (Host.Serial)
{
finalProt = Protocols.Serial;
protOK = true;
}
break;
case Protocols.RDP:
if (Host.RDP)
{
finalProt = Protocols.RDP;
protOK = true;
}
break;
case Protocols.VNC:
if (Host.VNC)
{
finalProt = Protocols.VNC;
protOK = true;
}
break;
}
if (protOK == false)
{
nConI = null;
}
else
{
nConI.Protocol = finalProt;
nConI.SetDefaultPort();
nNode.Tag = nConI;
Windows.treeForm.tvConnections.SelectedNode.Nodes.Add(nNode);
if (Node.GetNodeType(nNode.Parent) == Node.Type.Container)
{
nConI.Parent = nNode.Parent.Tag;
}
ConnectionList.Add(nConI);
}
}
}
public static object ImplicitMatch(RubyScope /*!*/ scope, RubyRegex /*!*/ self)
{
return(MatchIndex(scope, self, Protocols.CastToString(scope.RubyContext, scope.GetInnerMostClosureScope().LastInputLine)));
}
public AcceptRule(FireWallChains chain, string networkInterface, Protocols protocol, ICMPTypes?icmpType, IPAddress source, IPAddress sourceNetworkMask,
FirewallPort sourcePort, IPAddress destination, IPAddress destinationNetworkMask, FirewallPort destinationPort,
ConnectionStateTypes[] connectionStates, string note) :
base(chain, networkInterface, protocol, icmpType, source, sourceNetworkMask, sourcePort, destination, destinationNetworkMask, destinationPort, connectionStates, note)
{
}
public Protocols.ToolkitResultProtocol AddPOToSchedule(Protocols.Contracts.AddPOToScheduleSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.AddPOToScheduleSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.AddPOToScheduleSetup(setupParam.ContractIDNum, setupParam.ScheduleIDNum, setupParam.POIDNum, setupParam.POAmount);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.ContractIDNum = setupParam.ContractIDNum;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.ScheduleIDNum = setupParam.ScheduleIDNum;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.POIDNum = setupParam.POIDNum;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.PaymentOption = setupParam.PaymentOption;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.PaymentTerms = setupParam.PaymentTerms;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.POAmount = setupParam.POAmount;
}
if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
{
setup.PODate = setupParam.PODate;
}
if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
{
setup.ExpireDate = setupParam.ExpireDate;
}
if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
{
setup.POStatus = setupParam.POStatus;
}
return new Protocols.ToolkitResultProtocol( toolkit.AddPOToSchedule(setup) );
}
internal static RubyRegexOptions ObjectToIgnoreCaseOption(object obj)
{
return(Protocols.IsTrue(obj) ? RubyRegexOptions.IgnoreCase : RubyRegexOptions.NONE);
}
public Protocols.ToolkitResultProtocol CreateContract(Protocols.Contracts.CreateContractSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.CreateContractSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.CreateContractSetup(setupParam.Title);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.ContractIDNum = setupParam.ContractIDNum;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.Title = setupParam.Title;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.CreateDate = setupParam.CreateDate;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.AccountIDNum = setupParam.AccountIDNum;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.AccountName = setupParam.AccountName;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.ContactFirstName = setupParam.ContactFirstName;
}
if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
{
setup.ContactLastName = setupParam.ContactLastName;
}
if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
{
setup.ContactPhone = setupParam.ContactPhone;
}
if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
{
setup.ContractType = setupParam.ContractType;
}
if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
{
setup.Terms = setupParam.Terms;
}
if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
{
setup.PriceProgram = setupParam.PriceProgram;
}
if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
{
setup.Status = setupParam.Status;
}
if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
{
setup.AdminUserName = setupParam.AdminUserName;
}
if( Global.IsPropertyDirty(8192, setupParam.DirtyFieldFlags) )
{
setup.BillToSiteIDNum = setupParam.BillToSiteIDNum;
}
if( Global.IsPropertyDirty(16384, setupParam.DirtyFieldFlags) )
{
setup.ShipToSiteIDNum = setupParam.ShipToSiteIDNum;
}
if( Global.IsPropertyDirty(32768, setupParam.DirtyFieldFlags) )
{
setup.StartDate = setupParam.StartDate;
}
if( Global.IsPropertyDirty(65536, setupParam.DirtyFieldFlags) )
{
setup.ExpireDate = setupParam.ExpireDate;
}
if( Global.IsPropertyDirty(131072, setupParam.DirtyFieldFlags) )
{
setup.DefaultStartDate = setupParam.DefaultStartDate;
}
if( Global.IsPropertyDirty(262144, setupParam.DirtyFieldFlags) )
{
setup.DefaultExpirationDate = setupParam.DefaultExpirationDate;
}
if( Global.IsPropertyDirty(524288, setupParam.DirtyFieldFlags) )
{
setup.UserName = setupParam.UserName;
}
if( Global.IsPropertyDirty(1048576, setupParam.DirtyFieldFlags) )
{
setup.Queue = setupParam.Queue;
}
if( Global.IsPropertyDirty(2097152, setupParam.DirtyFieldFlags) )
{
setup.IsWarranty = setupParam.IsWarranty;
}
if( Global.IsPropertyDirty(4194304, setupParam.DirtyFieldFlags) )
{
setup.IsEvergreen = setupParam.IsEvergreen;
}
if( Global.IsPropertyDirty(8388608, setupParam.DirtyFieldFlags) )
{
setup.RenewPriorDays = setupParam.RenewPriorDays;
}
if( Global.IsPropertyDirty(16777216, setupParam.DirtyFieldFlags) )
{
setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
}
if( Global.IsPropertyDirty(33554432, setupParam.DirtyFieldFlags) )
{
foreach(Protocols.AdditionalFieldProtocol field in setupParam.AdditionalFields){setup.AdditionalFields.Append( field.FieldName, field.FieldType, field.FieldValue);}
}
return new Protocols.ToolkitResultProtocol( toolkit.CreateContract(setup) );
}
public void SendMessage(string name, string location, Protocols protocol)
{
string request = "";
if (location != String.Empty)
{
//format update location
switch (protocol)
{
case Protocols.WHOIS:
request = $"{name} {location}";
break;
case Protocols.HTTP09:
request = $"PUT /{name}\r\n" +
$"\r\n" +
$"{location}";
break;
case Protocols.HTTP10:
request = $"POST /{name} HTTP/1.0\r\n" +
$"Content-Length: {location.Length}\r\n" +
$"\r\n" +
$"{location}";
break;
case Protocols.HTTP11:
request = $"POST / HTTP/1.1\r\n" +
$"Host: {Program.settings.IPAddress}\r\n" +
$"Content-Length: {$"name={name}&location={location}".Length - 1}\r\n" +
$"\r\n" +
$"name={name}&location={location}";
break;
}
}
else
{
switch (protocol)
{
case Protocols.WHOIS:
request = $"{name}";
break;
case Protocols.HTTP09:
request = $"GET /{name}";
break;
case Protocols.HTTP10:
request = $"GET /?{name} HTTP/1.0\r\n\r\n";
break;
case Protocols.HTTP11:
request = $"GET /?name={name} HTTP/1.1\r\n" +
$"Host: {Program.settings.IPAddress}\r\n" +
$"\r\n";
break;
}
}
if (!bSendMessage(request))
{
log.write(LogLevel.INFO, $"Connection to server lost!");
}
else
{
log.write(LogLevel.INFO, $"You > {request}");
log.write(LogLevel.INFO, $"Recieved > " + new StreamReader(nets).ReadToEnd());
}
ConnectToAddress();
}
public static object /*!*/ ToSeconds(RubyTime /*!*/ self)
{
return(Protocols.Normalize(self.TicksSinceEpoch / 10000000));
}
public static object IsNonZero(UnaryOpStorage /*!*/ isZeroStorage, object self)
{
var isZero = isZeroStorage.GetCallSite("zero?");
return(Protocols.IsTrue(isZero.Target(isZero, self)) ? null : self);
}
public Protocols.ToolkitResultProtocol CreateSchedule(Protocols.Contracts.CreateScheduleSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.CreateScheduleSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.CreateScheduleSetup(setupParam.ContractIDNum);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.ContractIDNum = setupParam.ContractIDNum;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.ScheduleIDNum = setupParam.ScheduleIDNum;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.BillSiteIDNum = setupParam.BillSiteIDNum;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.BillingATTN = setupParam.BillingATTN;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.ShipToSiteIDNum = setupParam.ShipToSiteIDNum;
}
if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
{
setup.PriceProgram = setupParam.PriceProgram;
}
if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
{
setup.BillingFrequency = setupParam.BillingFrequency;
}
if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
{
setup.BillingOption = setupParam.BillingOption;
}
if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
{
setup.BillingPeriodStartDate = setupParam.BillingPeriodStartDate;
}
if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
{
setup.FirstBillingDate = setupParam.FirstBillingDate;
}
if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
{
setup.ChargeStartDate = setupParam.ChargeStartDate;
}
if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
{
setup.ChargeEndDate = setupParam.ChargeEndDate;
}
if( Global.IsPropertyDirty(8192, setupParam.DirtyFieldFlags) )
{
foreach(Protocols.AdditionalFieldProtocol field in setupParam.AdditionalFields){setup.AdditionalFields.Append( field.FieldName, field.FieldType, field.FieldValue);}
}
return new Protocols.ToolkitResultProtocol( toolkit.CreateSchedule(setup) );
}
public static object Offset(RubyTime /*!*/ self)
{
return(Protocols.Normalize(self.GetCurrentZoneOffset().Ticks / 10000000));
}
public Protocols.ToolkitResultProtocol LogContractNote(Protocols.Contracts.LogContractNoteSetupProtocol setupParam)
{
ClarifySession session = Global.GetSession( AuthHeader );
FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
FChoice.Toolkits.Clarify.Contracts.LogContractNoteSetup setup;
switch( setupParam.ConstructorCue )
{
case 0:
setup = new FChoice.Toolkits.Clarify.Contracts.LogContractNoteSetup(setupParam.ContractIDNum, setupParam.Notes);
break;
default:
throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
}
if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
{
setup.ContractIDNum = setupParam.ContractIDNum;
}
if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
{
setup.ActionType = setupParam.ActionType;
}
if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
{
setup.Notes = setupParam.Notes;
}
if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
{
setup.InternalUseOnlyNotes = setupParam.InternalUseOnlyNotes;
}
if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
{
setup.LogDate = setupParam.LogDate;
}
if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
{
setup.UserName = setupParam.UserName;
}
if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
{
setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
}
if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
{
foreach(Protocols.AdditionalFieldProtocol field in setupParam.AdditionalFields){setup.AdditionalFields.Append( field.FieldName, field.FieldType, field.FieldValue);}
}
return new Protocols.ToolkitResultProtocol( toolkit.LogContractNote(setup) );
}
public static void PutsEmptyLine(BinaryOpStorage /*!*/ writeStorage, object self)
{
Protocols.Write(writeStorage, self, MutableString.CreateAscii("\n"));
}
public static Connection.Info CreateQuicky(string ConString,
Protocols Protocol = Protocols.NONE)
{
try
{
Uri Uri = new Uri((string)("dummyscheme" + Uri.SchemeDelimiter + ConString));
if (!string.IsNullOrEmpty(Uri.Host))
{
Connection.Info newConnectionInfo = new Connection.Info();
newConnectionInfo.Name = string.Format(Language.strQuick, Uri.Host);
newConnectionInfo.Protocol = Protocol;
newConnectionInfo.Hostname = Uri.Host;
if (Uri.Port == -1)
{
newConnectionInfo.Port = 0;
}
else
{
newConnectionInfo.Port = Uri.Port;
}
newConnectionInfo.IsQuicky = true;
Windows.quickyForm.ConnectionInfo = newConnectionInfo;
if (Protocol == Protocols.NONE)
{
Windows.quickyPanel.Show(frmMain.Default.pnlDock, DockState.DockBottom);
Windows.quickyPanel.BringToFront();
Windows.quickyPanel.Activate();
Windows.quickyPanel.Show();
Windows.quickyPanel.Focus();
}
return newConnectionInfo;
}
}
catch (Exception ex)
{
MessageCollector.AddMessage(MessageClass.ErrorMsg,
Language.strQuickConnectFailed + Constants.vbNewLine +
ex.Message);
}
return null;
}
public static object /*!*/ Output(BinaryOpStorage /*!*/ writeStorage, object self, object value)
{
Protocols.Write(writeStorage, self, value);
return(self);
}
public ForwardedPort SetProtocol(Protocols protocol)
{
_protocol = protocol;
return this;
}
public DaveInterface(FD fd, string name, int localMPI, Protocols useProto, ProfiBusSpeed speed)
{
Pointer = daveNewInterface(fd, name, localMPI, (int)useProto, (int)speed);
}
