Nebol's Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
Possible values for the flags in the Integration table:

<code csharp>
	/// <summary>
	/// The Status field of the Integration table. NOT the same as the Status field in the IntegrationQueue table.
	/// </summary>
	public enum IntegrationStatusEnum
	{
		/// <summary>
		/// If the Status is Invalid (0) then it's an indication that something is very wrong, that should never happen
		/// </summary>
		Invalid = 0,
		/// <summary>
		/// If Status is Enabled then the integration is... enabled. 
		/// </summary>
		Enabled = 1,
		/// <summary>
		/// If Status is Paused, submits are accepted, queue is filling up, but NOT processed until integration is Enabled again
		/// </summary>
		Paused = 2,
		/// <summary>
		/// If Status is Ignored, queue is NOT filling up, submits are totally ignored. 
		/// </summary>
		Ignore = 3,
		/// <summary>
		/// NOT FULLY IMPLEMENTED YET, DO NOT USE!
		/// If Status is Scheduled then there is a schedule for when the integration should be enabled
		/// Useful for dealing with service windows so there is no need to Pause/Enable the integration manually in the middle of the night
		/// The status will be inferred from a schedule in the IntegrationSchedule table. 
		/// Default is Enabled. Higher status overrides lower, ie if schedule A says the integration
		/// is Enabled and schedule B says it's Ignore, then status is Ignore
		/// </summary>
		Scheduled = 4
	};

	/// <summary>
	/// This is the values for the Direction field 
	/// Mostly for information, but it is also used for dealing with healthchecks:
	/// If Direction is Outgoing and a healthcheck says there is a problem then it will not try to send anything
	/// If Direction is Incoming and a healtchcheck says there is a problem, Connection will still be Up and it will STILL accept incoming calls
	/// </summary>
	public enum DirectionEnum
	{
		/// <summary>
		/// It should never be None (0), if it is then there's a problem
		/// </summary>
		None = 0,
		/// <summary>
		/// This is an Outgoing integration meaning it will make calls to another service
		/// </summary>
		Outgoing,
		/// <summary>
		/// This is an Incoming integration meaning it will accept calls from another service
		/// </summary>
		Incoming,
		/// <summary>
		/// Not outgoing nor incoming, perhaps just a local task
		/// </summary>
		None
	}

	/// <summary>
	/// The Connection field is used for dealing with healthchecks
	/// An integration can be Enabled but if a healthcheck says that Connection is Down it will not make any outgoing calls
	/// </summary>
	public enum ConnectionEnum
	{
		/// <summary>
		/// Connection is Down. No calls will be made until it's Up again
		/// </summary>
		Down = 0,
		/// <summary>
		/// Connection is Up. All good.
		/// </summary>
		Up
	};
</code>

Possible values for the flags in the IntegrationQueue table:

<code csharp>
	/// <summary>
	/// The Status field for the IntegrationQueue, not the same as the Status field for the Integration
	/// </summary>
	public enum StatusEnum
	{
		/// <summary>
		/// This is a new item that has not been processed yet
		/// </summary>
		New = 1,
		/// <summary>
		/// This was successfully processed, nothing more will be done
		/// </summary>
		Success = 2,
		/// <summary>
		/// There was an error, it will try again according to the RetryScheme of the integration
		/// </summary>
		Error = 3,
		/// <summary>
		/// It has been rejected completely, it will not try again (because it would just fail again)
		/// This will never be accepted, there could be a permanent error in the data etc
		/// </summary>
		Rejected = 4,
		/// <summary>
		/// This status means that it has tried so many times, it is time to give up.
		/// </summary>
		GaveUp = 5
	}

	/// <summary>
	/// The Command field is used to directly control the integration, to override what should be done with the IntegrationQueue item
	/// </summary>
	public enum CommendEnum
	{
		/// <summary>
		/// No special action
		/// </summary>
		None = 0,
		/// <summary>
		/// The request will be tried again, immediately (not wait according to the schedule)
		/// It doesn't matter what the current status is, even if it is Success it will still try again.
		/// </summary>
		Reprocess_Request = 1,
		/// <summary>
		/// This command will make it give up immediately, do not try again (even if the schedule says so)
		/// </summary>
		GiveUp = 2,
		/// <summary>
		/// This command will process the RESPONSE again. (It will call the ProcessResponse() method if you have overridden that method)
		/// For example, if you have split it up so that in ProcessRequest() you call an API to get some data, and then in ProcessResponse()
		/// you process that data and store it tables.... and you don't want to call the API again to get new data, you just want to 
		/// try to process it again, using the same data as the first time.
		/// </summary>
		Reprocess_Response = 3
	}
</code>
Nebol's Wiki

User Tools

Site Tools

Page Tools
