public static Response HandleRequest(Request request)
{
RequestTypes reqType = request.RequestType;
int id = request.Id;
DateTime dt = request.Datetime;
double val = request.Value;
switch (reqType)
{
case RequestTypes.CREATE:
{
return(Create(id, dt, val));
}
case RequestTypes.READ:
{
return(Read(id));
}
case RequestTypes.UPDATE:
{
return(Update(id, dt, val));
}
case RequestTypes.DELETE:
{
return(Delete(id));
}
default:
throw new Exception();
}
}
public void SendRequest(RequestTypes reqType)
{
char sendChar = v_cardTypeRequest;
/*switch (variant) {
* case 0:
* sendChar = v_tap;
* break;
* case 1:
* sendChar = v_slide;
* break;
* case -1:
* sendChar = v_cardTypeRequest;
* break;
* default:
* sendChar = v_tap;
* break;
* }*/
try {
List <byte> toSend = new List <byte> ();
toSend.Add((byte)sendChar);
SendData(a_request, toSend.ToArray());
} catch (Exception e) {
DataLogger.LogError(this.name, e);
}
}
/// <summary>
/// Sends the request encrypted.
/// </summary>
/// <param name="requestData">The request data.</param>
public void SendRequest <T>(RequestTypes requestType, T request, bool encrypted) where T : class
{
//string requestString = XmlSerializationHelper.Serialize<T>(request);
//RequestHeader header = null;
//byte[] publicKey = null;
//if( encrypted )
//{
// header = RequestBuilder.BuildRequestHeader(
// EncryptionTypes.Aes,
// CompressionTypes.None,
// requestType);
// publicKey = EncryptionHelper.EncodeKeyParameter(
// _serverAuthority.GetPublicKeyParameter());
// header.MessageHeader.EncryptionHeader.PublicKey = publicKey;
//} else
//{
// header = RequestBuilder.BuildRequestHeader(
// EncryptionTypes.None,
// CompressionTypes.None,
// requestType);
//}
//_socket.SendData(XmlSerializationHelper.Serialize<RequestHeader>(header));
//_socket.SendData(RequestBuilder.ProcessRequest(
// _serverAuthority,
// _serverPublicKey,
// header,
// XmlSerializationHelper.Serialize<T>(request)));
}
public override void Connect()
{
if (wSocket != null)
{
HTTPManager.Logger.Warning("WebSocketTransport", "Start - WebSocket already created!");
}
else
{
if (base.State != TransportStates.Reconnecting)
{
base.State = TransportStates.Connecting;
}
RequestTypes type = (base.State != TransportStates.Reconnecting) ? RequestTypes.Connect : RequestTypes.Reconnect;
Uri uri = base.Connection.BuildUri(type, this);
wSocket = new VRC.Core.BestHTTP.WebSocket.WebSocket(uri);
VRC.Core.BestHTTP.WebSocket.WebSocket webSocket = wSocket;
webSocket.OnOpen = (OnWebSocketOpenDelegate)Delegate.Combine(webSocket.OnOpen, new OnWebSocketOpenDelegate(WSocket_OnOpen));
VRC.Core.BestHTTP.WebSocket.WebSocket webSocket2 = wSocket;
webSocket2.OnMessage = (OnWebSocketMessageDelegate)Delegate.Combine(webSocket2.OnMessage, new OnWebSocketMessageDelegate(WSocket_OnMessage));
VRC.Core.BestHTTP.WebSocket.WebSocket webSocket3 = wSocket;
webSocket3.OnClosed = (OnWebSocketClosedDelegate)Delegate.Combine(webSocket3.OnClosed, new OnWebSocketClosedDelegate(WSocket_OnClosed));
VRC.Core.BestHTTP.WebSocket.WebSocket webSocket4 = wSocket;
webSocket4.OnErrorDesc = (OnWebSocketErrorDescriptionDelegate)Delegate.Combine(webSocket4.OnErrorDesc, new OnWebSocketErrorDescriptionDelegate(WSocket_OnError));
base.Connection.PrepareRequest(wSocket.InternalRequest, type);
wSocket.Open();
}
}
/// <summary>
/// NOTE: for now request message is string but we'll change it to an interface that is capable of translating itself into xml!
/// </summary>
/// <param name="transactionId"></param>
/// <param name="_requestDateTime"></param>
/// <param name="_requestType"></param>
/// <param name="requestMessage"></param>
public BaseRequest(Guid transactionId, DateTime requestDateTime, RequestTypes requestType, RequestMessageBase requestMessage)
{
_transactionId = transactionId;
_requestDateTime = requestDateTime;
_requestType = requestType;
_requestMessage = requestMessage;
}
/// <summary>
/// Gets the type of request based on the call type
/// </summary>
/// <param name="callType">The call type to be evaluated</param>
private static RequestTypes GetRequestType(CallTypes callType)
{
RequestTypes requestType = RequestTypes.StandardGetRequest;
switch (callType)
{
case CallTypes.NewAuthorization:
requestType = RequestTypes.NewToken;
break;
case CallTypes.RefreshAuthorization:
requestType = RequestTypes.RefreshToken;
break;
case CallTypes.Command:
requestType = RequestTypes.StandardPostRequest;
break;
case CallTypes.Request:
requestType = RequestTypes.StandardGetRequest;
break;
}
return(requestType);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,RequestTypeDescription,LastUpdated,Active,Team")] RequestTypes requestTypes)
{
if (id != requestTypes.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(requestTypes);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RequestTypesExists(requestTypes.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["Team"] = new SelectList(_context.Teams, "Id", "TeamDescription", requestTypes.Team);
return(View(requestTypes));
}
internal async Task SendRequestAsync(RequestTypes type, Memory <byte> data, CancellationToken cancellationToken = default(CancellationToken))
{
const int length = 8;
void WriteBuffer(Memory <byte> memory)
{
var span = memory.Span;
span.Write(data.Length / 8)
.Write((byte)type)
.Write(REVISION);
}
if (data.Length % length != 0)
{
throw new InvalidOperationException();
}
using (var slot = MemoryPool <byte> .Shared.Rent(length))
{
var headerMemory = slot.Memory.Slice(0, length);
WriteBuffer(headerMemory);
await this.stream.WriteAsync(headerMemory, cancellationToken);
await this.stream.WriteAsync(data, cancellationToken);
}
}
public override void Connect()
{
if (EventSource != null)
{
HTTPManager.Logger.Warning("ServerSentEventsTransport", "Start - EventSource already created!");
return;
}
// Skip the Connecting state if we are reconnecting. If the connect succeeds, we will set the Started state directly
if (this.State != TransportStates.Reconnecting)
{
this.State = TransportStates.Connecting;
}
RequestTypes requestType = this.State == TransportStates.Reconnecting ? RequestTypes.Reconnect : RequestTypes.Connect;
Uri uri = Connection.BuildUri(requestType, this);
EventSource = new EventSource(uri);
EventSource.OnOpen += OnEventSourceOpen;
EventSource.OnMessage += OnEventSourceMessage;
EventSource.OnError += OnEventSourceError;
EventSource.OnClosed += OnEventSourceClosed;
#if !UNITY_WEBGL || UNITY_EDITOR
// Disable internal retry
EventSource.OnRetry += (es) => false;
#endif
// Start connecting to the server.
EventSource.Open();
}
public IPaymentProcessor CreateProcessor(RequestTypes requestTypes)
{
IPaymentProcessor paymentProcessor = null;
switch (requestTypes)
{
case RequestTypes.Books:
{
paymentProcessor = new BookProcessor(_logger, _componentSupplier.GetComponents());
break;
}
case RequestTypes.MemberShips:
{
paymentProcessor = new MemberShipProcessor(_logger, _componentSupplier.GetComponents());
break;
}
case RequestTypes.UpgradeMemberShip:
{
paymentProcessor = new UpgradeMemberShipProcesor(_logger, _componentSupplier.GetComponents());
break;
}
case RequestTypes.PhysicalProduct:
{
paymentProcessor = new PhysicalProductProcessor(_logger, _componentSupplier.GetComponents());
break;
}
}
return(paymentProcessor);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public static void SendRegularRequest(RequestTypes requestType, ByteBuffer requestBuffer, RequestParseCallback requestParseCallback, RequestViewCallback requestViewCallback)
{
if (requestType == RequestTypes.ReconnectToServer)
{
Init();
requestViewCallback?.Invoke(RequestStates.Completed);
return;
}
if ((DateTime.Now - lastPingTime).TotalMilliseconds > Settings.pingValueLifeTime * 3)
Init();
if ((connectState != ConnectStates.AuthPassed) && (userToken == null) && (login == null))
return;
sendPacketBuffer.Reset((int)HeaderOffsets.SecondEnd);
sendPacketBuffer.Add((byte)ClientPacketTypes.Request);
sendPacketBuffer.Add((byte)requestType);
if (requestBuffer != null)
sendPacketBuffer.AddBytes(requestBuffer, 0);
SendRequestToServer(requestParseCallback, requestViewCallback);
if (WaitForPacket(ClientPacketTypes.RequestAnswer, waitPacketTimeout) == false)
{
Console.WriteLine("socket.Connected: " + socket.Connected);
socket.Disconnect(false);
ConnectToServer();
}
Update();
}
/// <summary>
/// Websocket transport specific connection logic. It will create a WebSocket instance, and starts to connect to the server.
/// </summary>
public override void Connect()
{
if (wSocket != null)
{
HTTPManager.Logger.Warning("WebSocketTransport", "Start - WebSocket already created!");
return;
}
// Skip the Connecting state if we are reconnecting. If the connect succeeds, we will set the Started state directly
if (this.State != TransportStates.Reconnecting)
{
this.State = TransportStates.Connecting;
}
RequestTypes requestType = this.State == TransportStates.Reconnecting ? RequestTypes.Reconnect : RequestTypes.Connect;
Uri uri = Connection.BuildUri(requestType, this);
// Create the WebSocket instance
wSocket = new WebSocket.WebSocket(uri);
// Set up eventhandlers
wSocket.OnOpen += WSocket_OnOpen;
wSocket.OnMessage += WSocket_OnMessage;
wSocket.OnClosed += WSocket_OnClosed;
wSocket.OnErrorDesc += WSocket_OnError;
#if !UNITY_WEBGL || UNITY_EDITOR
// prepare the internal http request
Connection.PrepareRequest(wSocket.InternalRequest, requestType);
#endif
// start opening the websocket protocol
wSocket.Open();
}
public void TestSocketPayloadSerialization()
{
var serializer = new SocketPayloadSerializer();
const RequestTypes type = RequestTypes.Test;
const int intVal = 5;
var payload = new TestRequest
{
Type = type,
RequestInt = intVal
};
string data;
Assert.IsTrue(serializer.Serialize(payload, out data));
Assert.IsNotNull(data);
TestRequest deserialized;
Assert.IsTrue(serializer.Deserialize(data, out deserialized));
Assert.IsNotNull(deserialized);
Assert.AreEqual(payload.Type, deserialized.Type);
Assert.AreEqual(payload.RequestInt, deserialized.RequestInt);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public static void Login(ByteBuffer buffer, RequestViewCallback requestViewCallback)
{
RequestTypes requestType = (RequestTypes)buffer.GetByte();
if ((requestType != RequestTypes.AuthByLogin) && (requestType != RequestTypes.AuthByToken))
{
if (requestType == RequestTypes.Error)
{
Client.Log(buffer.GetLongString());
}
return;
}
connectState = ConnectStates.AuthPassed;
ushort serverVersion = buffer.GetUShort();
serverName = buffer.GetShortString();
userName = buffer.GetShortString();
if (requestType == RequestTypes.AuthByLogin)
{
userToken = buffer.GetShortString();
Client.Log("Get token: " + userToken);
}
if (Settings.serverVersion != serverVersion)
{
Client.Log("Версии клиента и сервера различаются " + serverVersion + " - " + Settings.serverVersion + ". Обновите клиент", LogTypes.Error);
}
Client.Log("Auth success. Server version: " + serverVersion);
}
public Request(DateTime date_, RequestTypes type_, int company_id_, string api_key_)
{
date = date_;
type.Add(type_);
company_id = company_id_;
api_key = api_key_;
}
} // constructor
public Request(RequestTypes requestType, DateTime time, ASafeLog log)
{
RequestType = requestType;
Time = time;
log.Debug("New request created: {0}", this);
} // constructor
private string mapUri(RequestTypes requestType)
{
return(requestType switch
{
RequestTypes.CreateBrn => "brn/createBRN",
RequestTypes.UpdateBrn => "brn/updateBRN",
RequestTypes.CreateAccount => "accounts/createAccount",
RequestTypes.AccountEmailInvites => "accounts/SendAccountInvites",
RequestTypes.RequestAccountOTP => "accounts/RequestAccountOTP",
RequestTypes.CreateDepartment => "departments/CreateDepartment",
RequestTypes.CreateIndividual => "individuals/CreateIndividual",
RequestTypes.UpdateIndividual => "individuals/UpdateIndividual",
RequestTypes.ConfigureEndpoint => "endpoint/SetupEndpoint",
RequestTypes.CreateNominationDriver => "nominations/CreateNominatedDriver",
RequestTypes.UpdateNominationDriver => "nominations/UpdateNominatedDriver",
RequestTypes.CreateVehicle => "vehicles/CreateVehicle",
RequestTypes.UpdateVehicle => "vehicles/UpdateVehicle",
RequestTypes.CreateDealerStock => "DealerStock/CreateDealerStockInstruction",
RequestTypes.ActivateVehicle => "vehicles/ActivateVehicle",
RequestTypes.DeactivateVehicle => "vehicles/DeactivateVehicle",
RequestTypes.CreateQuote => "instructions/CreateQuote",
RequestTypes.UploadDocuments => "documents/UploadDocuments",
_ => throw new Exception("Invalid endpoint url")
});
/// <summary>
/// Конвертирует RequestTypes в строку для JSON запроса.
/// </summary>
public static string EnumTypeToString(RequestTypes type)
{
switch (type)
{
case RequestTypes.AddGame:
return(RequestJsonTypes.AddGame);
case RequestTypes.Shot:
return(RequestJsonTypes.Shot);
case RequestTypes.SetField:
return(RequestJsonTypes.SetField);
case RequestTypes.GetGames:
return(RequestJsonTypes.GetGames);
case RequestTypes.JoinTheGame:
return(RequestJsonTypes.JoinTheGame);
case RequestTypes.Ping:
return(RequestJsonTypes.Ping);
case RequestTypes.BadRequest:
throw new ArgumentException("Невозможно преобразовать BadRequest", nameof(type));
}
throw new ArgumentException($"Тип не определён, тип - {type.ToString()}.", nameof(type));
}
public IActionResult CheckCommits(GitHubInformationForm form, RequestTypes request)
{
var commintsNumber = 10;
IList <Commit> commits = new List <Commit>();
var url = string.Empty;
if (!string.IsNullOrEmpty(form.UserName) && !string.IsNullOrEmpty(form.RepositoryName))
{
var gihubSettings = new GitHubSettings {
UserName = form.UserName, RepositoryName = form.RepositoryName, RequestType = request
};
url = _urlGenerator.GenerateUrlForGitHubApi(gihubSettings);
try
{
commits = _githubService.ProcessCommits(url);
if (commits.Any())
{
commits = commits.OrderByDescending(c => c.PurpleCommit.Committer.DateOfCommit).Take(commintsNumber).ToList();
}
}
catch (Exception ex)
{
ViewBag.InnerException = ex.Message;
}
}
return(PartialView("_Commits", commits));
}
public NetDataRequest(RequestTypes type, Dictionary <string, ObjectWrapper> values)
{
Type = type;
Values = values;
Result = RequestResult.Ok;
}
private PaymentRequest GetPaymentRequest(RequestTypes requestTypes)
{
return(new PaymentRequest
{
Amount = amount,
RequestType = requestTypes
});
}
/// <summary>
/// The base of the Request class
/// </summary>
/// <param name="reqType"></param>
/// <param name="path"></param>
/// <returns></returns>
protected KeepaRequest GetBaseRequest(ApiSpecificRequestTypes reqType, string path)
{
//KeepaRequest r = new KeepaRequest();
this.RequestType = RequestTypes.Keepa;
this.KeepaRequestType = reqType;
this.path = path;
return(this);
}
public TNTShipRequest(DateTime CollectionDate, RequestTypes requestType, TNTPackageAnalyser pa, bool Debug = false)
{
this.reqestType = requestType;
this.pa = pa;
this.Debug = Debug;
this.xml = new MyXMLDocument();
dateformatinfo = new DateTimeFormatInfo(); //neutral culture, it has / as date separator
MakeFixedElements(CollectionDate);
}
// GET: RequestTypes/Create
public IActionResult Create()
{
ViewData["Team"] = new SelectList(_context.Teams, "Id", "TeamDescription");
var model = new RequestTypes();
model.LastUpdated = System.DateTime.Now;
model.Active = true;
return(View(model));
}
public DbCommand(PaDbContext context, RequestTypes command, NetworkStream stream)
{
_command = command;
_stream = stream;
depsRepo = new DepartmentRepository(context);
positionsRepo = new PositionRepository(context);
empsRepo = new EmployeeRepository(context);
payoutTypesRepo = new PayoutTypeRepository(context);
payoutsRepo = new PayoutRepository(context);
}
public Query(RequestTypes requestType)
{
RequestType = requestType;
_keywords = null;
_year = null;
_language = null;
_region = null;
_type = null;
_id = null;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="more">Is more data available.</param>
/// <param name="cmd"> Received command.</param>
/// <param name="buff">Received data.</param>
/// <param name="complete">Is frame complete.</param>
/// <param name="error">Received error ID.</param>
internal GXReplyData(RequestTypes more, Command cmd, GXByteBuffer buff, bool complete, byte error)
{
Data = new GXByteBuffer();
Clear();
MoreData = more;
Command = cmd;
Data = buff;
IsComplete = complete;
Error = error;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="more">Is more data available.</param>
/// <param name="cmd"> Received command.</param>
/// <param name="buff">Received data.</param>
/// <param name="complete">Is frame complete.</param>
/// <param name="error">Received error ID.</param>
internal GXReplyData(RequestTypes more, Command cmd, GXByteBuffer buff, bool complete, byte error)
{
Data = new GXByteBuffer();
Clear();
MoreData = more;
Command = cmd;
Data = buff;
IsComplete = complete;
Error = error;
}
public static ReturnT PerformJsonRequest <ReturnT>(string url, RequestTypes method, object postData)
{
//Initilize the http request
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
req.ContentType = "application/json";
req.Method = Enum.GetName(typeof(RequestTypes), method);
//If posting data - serialize it to a json object
if (method != RequestTypes.Get)
{
StringBuilder sbJsonRequest = new StringBuilder();
var T = postData.GetType();
foreach (var prop in T.GetProperties())
{
if (NativeTypes.Contains(prop.PropertyType))
{
sbJsonRequest.AppendFormat("\"{0}\":\"{1}\",", prop.Name.ToLower(), prop.GetValue(postData, null));
}
}
using (var sWriter = new StreamWriter(req.GetRequestStream()))
{
sWriter.Write("{" + sbJsonRequest.ToString().TrimEnd(',') + "}");
}
}
//Submit the Http Request
string responseJson = "";
try
{
using (var wResponse = req.GetResponse())
{
StreamReader sReader = new StreamReader(wResponse.GetResponseStream());
responseJson = sReader.ReadToEnd();
}
}
catch (WebException ex)
{
using (WebResponse response = ex.Response)
{
StreamReader sReader = new StreamReader(response.GetResponseStream());
responseJson = sReader.ReadToEnd();
}
}
if (typeof(ReturnT) == typeof(string))
{
return((ReturnT)Convert.ChangeType(responseJson, typeof(ReturnT)));
}
return(fastJSON.JSON.Instance.ToObject <ReturnT>(responseJson));
}
public Request CreateRequest(Request request, RequestTypes requestType)
{
request.CreatedUtc = DateTime.UtcNow;
request.LastModifiedUtc = DateTime.UtcNow;
request.Status = (int)RequestStatus.New;
request.RequestType = (int)requestType;
Repo.Add <Request>(request);
Repo.SaveChanges();
return(request);
}
public BaseResponseData(RequestTypes request, RequestResult result, Dictionary <string, object> data)
{
Request = request;
Result = result;
Data = data;
if (data.Count == 0)
{
Data = null;
}
}
/// <summary>
/// Constructor for Request
/// </summary>
/// <param name="request">request type (enum)</param>
/// <param name="trackControllerID">track controller id</param>
/// <param name="trainID">train id</param>
/// <param name="authority">authority/speed limit</param>
/// <param name="route">route information</param>
/// <param name="block">block information</param>
public Request(RequestTypes request, int trackControllerID,
int trainID, int authority, double speed, IRoute route,
IBlock block)
{
_requestType = request;
_trackControllerID = trackControllerID;
_trainID = trainID;
_trainAuthority = authority;
_trainRoute = route;
_block = block;
_issueDateTime = DateTime.Now;
Info = null;
_trainSpeed = speed;
}
public static RequestHeader BuildRequestHeader(EncryptionTypes encryptionType, CompressionTypes compressionType, RequestTypes requestType)
{
// first create headers
EncryptionHeader encryptionHeader = new EncryptionHeader()
{
EncryptionType = encryptionType
};
MessageHeader messageHeader = new MessageHeader()
{
CompressionType = compressionType,
EncryptionHeader = encryptionHeader
};
RequestHeader requestHeader = new RequestHeader()
{
RequestType = requestType,
MessageHeader = messageHeader
};
// send response header first
return requestHeader;
}
private static RequestBodyBuilder PopulateRequestParameters(UserOrganizationRequest org, RequestTypes requestType)
{
org.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
parameters.AppendRequestData("name", org.Name);
parameters.AppendRequestData("organizationtype", EnumUtility.ToApiString(org.OrganizationType));
if (!String.IsNullOrEmpty(org.Address))
{
parameters.AppendRequestData("address", org.Address);
}
if (!String.IsNullOrEmpty(org.City))
{
parameters.AppendRequestData("city", org.City);
}
if (!String.IsNullOrEmpty(org.State))
{
parameters.AppendRequestData("state", org.State);
}
if (!String.IsNullOrEmpty(org.PostalCode))
{
parameters.AppendRequestData("postalcode", org.PostalCode);
}
if (!String.IsNullOrEmpty(org.Country))
{
parameters.AppendRequestData("country", org.Country);
}
if (!String.IsNullOrEmpty(org.Phone))
{
parameters.AppendRequestData("phone", org.Phone);
}
if (!String.IsNullOrEmpty(org.Fax))
{
parameters.AppendRequestData("fax", org.Fax);
}
if (!String.IsNullOrEmpty(org.Website))
{
parameters.AppendRequestData("website", org.Website);
}
if (org.SlaPlanId != null)
{
parameters.AppendRequestData("slaplanid", org.SlaPlanId);
}
if (org.SlaPlanExpiry != null)
{
parameters.AppendRequestData("slaplanexpiry", org.SlaPlanExpiry);
}
return parameters;
}
/// <summary>
/// Creates an Uri instance for the given request type.
/// </summary>
Uri IConnection.BuildUri(RequestTypes type)
{
return (this as IConnection).BuildUri(type, null);
}
private RequestBodyBuilder PopulateRequestParameters(TroubleshooterAttachmentRequest troubleshooterAttachmentRequest, RequestTypes requestType)
{
troubleshooterAttachmentRequest.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
parameters.AppendRequestDataNonNegativeInt("troubleshooterstepid", troubleshooterAttachmentRequest.TroubleshooterStepId);
parameters.AppendRequestDataNonEmptyString("filename", troubleshooterAttachmentRequest.FileName);
parameters.AppendRequestDataNonEmptyString("contents", troubleshooterAttachmentRequest.Contents);
return parameters;
}
private RequestBodyBuilder PopulateRequestParameters(TroubleshooterStepRequest troubleshooterStepRequest, RequestTypes requestType)
{
troubleshooterStepRequest.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
if (requestType == RequestTypes.Create)
{
parameters.AppendRequestData("categoryid", troubleshooterStepRequest.CategoryId);
}
parameters.AppendRequestDataNonEmptyString("subject", troubleshooterStepRequest.Subject);
parameters.AppendRequestDataNonEmptyString("contents", troubleshooterStepRequest.Contents);
parameters.AppendRequestDataNonNegativeInt(requestType == RequestTypes.Create ? "staffid" : "editedstaffid",
troubleshooterStepRequest.StaffId);
if (troubleshooterStepRequest.DisplayOrder.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("displayorder", troubleshooterStepRequest.DisplayOrder.Value);
}
parameters.AppendRequestDataBool("allowcomments", troubleshooterStepRequest.AllowComments);
parameters.AppendRequestDataBool("enableticketredirection", troubleshooterStepRequest.EnableTicketRedirection);
if (troubleshooterStepRequest.RedirectDepartmentId.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("redirectdepartmentid", troubleshooterStepRequest.RedirectDepartmentId.Value);
}
if (troubleshooterStepRequest.TicketTypeId.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("tickettypeid", troubleshooterStepRequest.TicketTypeId.Value);
}
if(troubleshooterStepRequest.TicketPriorityId.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("ticketpriorityid", troubleshooterStepRequest.TicketPriorityId.Value);
}
parameters.AppendRequestDataNonEmptyString("ticketsubject", troubleshooterStepRequest.TicketSubject);
if (troubleshooterStepRequest.StepStatus.HasValue)
{
parameters.AppendRequestData("stepstatus", EnumUtility.ToApiString(troubleshooterStepRequest.StepStatus.Value));
}
parameters.AppendRequestDataArrayCommaSeparated("parentstepidlist", troubleshooterStepRequest.ParentStepIdList);
return parameters;
}
private static XElement SerializeXml(RequestTypes type, IRequestData data)
{
switch (type)
{
case RequestTypes.METAR:
var metarData = data as METAR;
if (metarData != null)
{
XAttribute id = metarData.Icao == null
? new XAttribute("p", metarData.Coordinates.ToString("p"))
: new XAttribute("icao", metarData.Icao);
XAttribute count = metarData.Count == 0 ? null : new XAttribute("count", metarData.Count);
XAttribute maxAge = metarData.MaxAge == 0 ? null : new XAttribute("maxage", metarData.MaxAge);
var element = new XElement("Metar",
id,
count,
maxAge);
return element;
}
break;
case RequestTypes.AvailableEpochs:
return new XElement("AvailableEpochs");
case RequestTypes.AvailableLevels:
return new XElement("AvailableLevels");
case RequestTypes.AvailableGeoMagModels:
return new XElement("AvailableGeomagModels");
case RequestTypes.Wind:
var windData = data as Wind;
if (windData != null)
{
var coords = new XAttribute("p", windData.Coordinates.ToString("p"));
var altitude = new XAttribute("z", windData.Altitude);
var unit = new XAttribute("u", Altitude.EnumToUnitCode(windData.Unit));
var epoch = new XAttribute("e", windData.Epoch.ToNWXString());
XAttribute id = windData.Id == null ? null : new XAttribute("id", windData.Id);
return new XElement("Wind",
coords,
altitude,
unit,
epoch,
id);
}
break;
case RequestTypes.Chart:
var chartData = data as Chart;
if (chartData != null)
{
var id = chartData.Id != null ? new XAttribute("id", chartData.Id) : null;
var width = new XAttribute("x", chartData.Width);
var height = new XAttribute("y", chartData.Height);
var level = new XAttribute("z", chartData.Level);
var epoch = new XAttribute("e", chartData.Epoch.ToNWXString());
var lat0 = new XAttribute("lat0", chartData.LowerLeftCoordinates.Latitude);
var lat1 = new XAttribute("lat1", chartData.UpperRightCoordinates.Latitude);
var lon0 = new XAttribute("lon0", chartData.LowerLeftCoordinates.Longitude);
var lon1 = new XAttribute("lon1", chartData.UpperRightCoordinates.Longitude);
var transparentBg = chartData.TransparentBackground
? new XAttribute("background", "transparent")
: null;
var layout = chartData.MapLayout ? new XAttribute("layout", "map") : null;
return new XElement("Chart",
id,
width,
height,
level,
epoch,
lat0,
lat1,
lon0,
lon1,
transparentBg,
layout,
from feature in chartData.Features
select new XElement("theme", feature));
}
break;
case RequestTypes.TAF:
var TAFData = data as TAF;
if (TAFData != null)
{
XAttribute id = TAFData.Icao == null
? new XAttribute("p", TAFData.Coordinates.ToString("p"))
: new XAttribute("icao", TAFData.Icao);
XAttribute count = TAFData.Count == 0 ? null : new XAttribute("count", TAFData.Count);
XAttribute maxAge = TAFData.MaxAge == 0 ? null : new XAttribute("maxage", TAFData.MaxAge);
var element = new XElement("Taf",
id,
count,
maxAge);
return element;
}
break;
}
return null;
}
private RequestBodyBuilder PopulateRequestParameters(KnowledgebaseCategoryRequest knowledgebaseCategoryRequest, RequestTypes requestType)
{
knowledgebaseCategoryRequest.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
parameters.AppendRequestDataNonEmptyString("title", knowledgebaseCategoryRequest.Title);
if (knowledgebaseCategoryRequest.CategoryType.HasValue)
{
parameters.AppendRequestData("categorytype",
EnumUtility.ToApiString(knowledgebaseCategoryRequest.CategoryType.Value));
}
if (knowledgebaseCategoryRequest.ParentCategoryId.HasValue)
{
parameters.AppendRequestData("parentcategoryid", knowledgebaseCategoryRequest.ParentCategoryId.Value);
}
if (knowledgebaseCategoryRequest.DisplayOrder.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("displayorder", knowledgebaseCategoryRequest.DisplayOrder.Value);
}
if (knowledgebaseCategoryRequest.ArticleSortOrder.HasValue)
{
parameters.AppendRequestData("articlesortorder",
EnumUtility.ToApiString(knowledgebaseCategoryRequest.ArticleSortOrder.Value));
}
parameters.AppendRequestDataBool("allowcomments", knowledgebaseCategoryRequest.AllowComments);
parameters.AppendRequestDataBool("allowrating", knowledgebaseCategoryRequest.AllowRating);
parameters.AppendRequestDataBool("ispublished", knowledgebaseCategoryRequest.IsPublished);
parameters.AppendRequestDataBool("uservisibilitycustom", knowledgebaseCategoryRequest.UserVisibilityCustom);
parameters.AppendRequestDataArrayCommaSeparated("usergroupidlist", knowledgebaseCategoryRequest.UserGroupIdList);
parameters.AppendRequestDataBool("staffvisibilitycustom", knowledgebaseCategoryRequest.StaffVisibilityCustom);
parameters.AppendRequestDataArrayCommaSeparated("staffgroupidlist", knowledgebaseCategoryRequest.StaffGroupIdList);
if (requestType == RequestTypes.Create && knowledgebaseCategoryRequest.StaffId.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("staffid", knowledgebaseCategoryRequest.StaffId.Value);
}
return parameters;
}
public void PrepareRequest(HTTPRequest request, RequestTypes type)
{
// Adding the cookie to the request is not required, as it's managed by the plugin automatically,
// but for now, we want to be really sure that it's added
request.Cookies.Add(Cookie);
}
private RequestBodyBuilder PopulateRequestParameters(KnowledgebaseCommentRequest knowledgebaseCommentRequest, RequestTypes requestType)
{
knowledgebaseCommentRequest.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
parameters.AppendRequestDataNonNegativeInt("knowledgebasearticleid", knowledgebaseCommentRequest.KnowledgebaseArticleId);
parameters.AppendRequestDataNonEmptyString("contents", knowledgebaseCommentRequest.Contents);
parameters.AppendRequestData("creatortype", EnumUtility.ToApiString(knowledgebaseCommentRequest.CreatorType));
if (knowledgebaseCommentRequest.CreatorId.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("creatorid", knowledgebaseCommentRequest.CreatorId.Value);
}
else
{
parameters.AppendRequestDataNonEmptyString("fullname", knowledgebaseCommentRequest.FullName);
}
parameters.AppendRequestDataNonEmptyString("email", knowledgebaseCommentRequest.Email);
if (knowledgebaseCommentRequest.ParentCommentId.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("parentcommentid", knowledgebaseCommentRequest.ParentCommentId.Value);
}
return parameters;
}
private RequestBodyBuilder PopulateRequestParameters(KnowledgebaseAttachmentRequest knowledgebaseAttachmentRequest, RequestTypes requestType)
{
knowledgebaseAttachmentRequest.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
parameters.AppendRequestDataNonNegativeInt("kbarticleid", knowledgebaseAttachmentRequest.KnowledgebaseArticleId);
parameters.AppendRequestDataNonEmptyString("filename", knowledgebaseAttachmentRequest.FileName);
parameters.AppendRequestDataNonEmptyString("contents", knowledgebaseAttachmentRequest.Contents);
return parameters;
}
public void ExecuteSendCommand(object sender, string command, GXPacket packet)
{
if (command != "ReadAARQNext" && command != "ReadNextInfo" && command != "ReadNext")
{
IsMoreDataAvailable = RequestTypes.None;
}
GXDLMSProperty prop = sender as GXDLMSProperty;
if (command == "InitRead")
{
LastNotifiedTransactionProgress = 0;
InitRead(sender, packet);
}
else if (command == "ReadSNRMSend")
{
LastNotifiedTransactionProgress = 0;
ReadSNRMSend(sender, packet);
}
else if (command == "ReadAARQ")
{
LastNotifiedTransactionProgress = 0;
ReadAARQ(sender, packet);
}
else if (command == "ReadAARQNext")
{
LastNotifiedTransactionProgress = 0;
ReadAARQNext(sender, packet);
}
else if (command == "ReadData")
{
LastNotifiedTransactionProgress = 0;
ReadData(prop, packet);
}
else if (command == "ReadDataType")
{
LastNotifiedTransactionProgress = 0;
ReadDataType(prop, packet);
}
else if (command == "WriteData")
{
LastNotifiedTransactionProgress = 0;
WriteData(prop, packet);
}
else if (command == "KeepAliveRequest")
{
LastNotifiedTransactionProgress = 0;
//Network connection don't need this.
if (!SupportNetworkSpecificSettings)
{
packet.AppendData(parser.GetKeepAlive());
}
}
else if (command == "DisconnectRequest")
{
LastNotifiedTransactionProgress = 0;
//Network connection don't need this.
if (!SupportNetworkSpecificSettings)
{
packet.AppendData(parser.DisconnectRequest());
}
}
else if (command == "ReadTableInfo")
{
if (this.Extension != null)
{
ReceivedData = null;
ExtraInfoPos = 0;
ExtraInfo.Clear();
List<GXObisCode> items = new List<GXObisCode>();
this.Extension.ReadExtraInfo(items);
if (items.Count != 0)
{
foreach (GXObisCode it in items)
{
ExtraInfo.Add(it, null);
}
GXObisCode item = items[0];
packet.AppendData(parser.Read(item.LogicalName, item.ObjectType, item.AttributeIndex)[0]);
}
}
}
else if (command == "ReadCapturePeriod")
{
ReceivedData = null;
GXDLMSTable table = sender as GXDLMSTable;
//Capture period is read only once.
if (table.CapturePeriod == 0)
{
if (parser.UseLogicalNameReferencing)
{
packet.AppendData(parser.Read(table.LogicalName, Gurux.DLMS.ObjectType.ProfileGeneric, 4)[0]);
}
else
{
packet.AppendData(parser.Read(table.ShortName, Gurux.DLMS.ObjectType.ProfileGeneric, 4)[0]);
}
}
}
else if (command == "ReadTableContent")
{
//Check start and end times.
DateTime starttm, endtm;
GXDLMSTable table = sender as GXDLMSTable;
(table as IGXPartialRead).GetStartEndTime(out starttm, out endtm);
LastNotifiedTransactionProgress = 0;
ReceivedData = null;
TryParse = false;
if (parser.UseLogicalNameReferencing)
{
packet.AppendData(parser.Read(table.LogicalName, Gurux.DLMS.ObjectType.ProfileGeneric, 3)[0]);
}
else
{
packet.AppendData(parser.Read(table.ShortName, Gurux.DLMS.ObjectType.ProfileGeneric, 3)[0]);
}
}
else if (command == "ReadNextInfo") //Read next part of the data or next item.
{
//Read next extra info.
if (IsMoreDataAvailable == Gurux.DLMS.RequestTypes.None)
{
GXObisCode item = ExtraInfo.Keys.ElementAt(ExtraInfoPos);
object data = parser.Read(item.LogicalName, item.ObjectType, item.AttributeIndex)[0];
packet.AppendData(data);
}
else //Read next part of the data.
{
Gurux.DLMS.RequestTypes readItem = Gurux.DLMS.RequestTypes.Frame;
if ((IsMoreDataAvailable & RequestTypes.Frame) == 0)
{
readItem = Gurux.DLMS.RequestTypes.DataBlock;
}
packet.AppendData(parser.ReceiverReady(readItem));
}
}
else if (command == "ReadNext") //Read next part of data.
{
Gurux.DLMS.RequestTypes readItem = Gurux.DLMS.RequestTypes.Frame;
if ((IsMoreDataAvailable & RequestTypes.Frame) == 0)
{
readItem = Gurux.DLMS.RequestTypes.DataBlock;
}
packet.AppendData(parser.ReceiverReady(readItem));
}
else if (command == "ReadTableData") //Read next part of data.
{
pg = Gurux.DLMS.GXDLMSClient.CreateObject(ObjectType.ProfileGeneric) as Gurux.DLMS.Objects.GXDLMSProfileGeneric;
GXDLMSTable table2 = sender as GXDLMSTable;
pg.CapturePeriod = table2.CapturePeriod;
foreach (GXDLMSProperty col in table2.Columns)
{
GXDLMSObject item = Gurux.DLMS.GXDLMSClient.CreateObject(col.ObjectType);
item.SetDataType(col.AttributeOrdinal, col.DLMSType);
item.SetUIDataType(col.AttributeOrdinal, col.ValueType);
item.LogicalName = col.LogicalName;
//Update scaler for register.
if (col is GXDLMSRegister && col.AttributeOrdinal == 2)
{
GXDLMSRegister r = col as GXDLMSRegister;
if (item.ObjectType == ObjectType.DemandRegister)
{
(item as Gurux.DLMS.Objects.GXDLMSDemandRegister).Scaler = r.Scaler;
}
else
{
(item as Gurux.DLMS.Objects.GXDLMSRegister).Scaler = r.Scaler;
}
}
pg.CaptureObjects.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(item, new GXDLMSCaptureObject(col.AttributeOrdinal, 0)));
}
LastNotifiedTransactionProgress = 0;
GXDLMSTable table = sender as GXDLMSTable;
ReceivedRows = 0;
TryParse = true;
ReceivedData = null;
IGXPartialRead partialRead = table as IGXPartialRead;
object name, data;
int EDISType = 0, Version = 0;
if (parser.UseLogicalNameReferencing)
{
name = table.LogicalName;
}
else
{
name = table.ShortName;
}
string ClockLN = "0.0.1.0.0.255";
if (partialRead.Type == PartialReadType.All)
{
data = parser.Read(name, ObjectType.ProfileGeneric, 2)[0];
}
else if (partialRead.Type == PartialReadType.Entry)
{
data = parser.ReadRowsByEntry(name, Convert.ToInt32((table as IGXPartialRead).Start), Convert.ToInt32((table as IGXPartialRead).End));
}
else
{
DateTime starttm = DateTime.MinValue, endtm = DateTime.MaxValue;
if (table.Columns.Count != 0)
{
GXDLMSProperty col = table.Columns[0] as GXDLMSProperty;
EDISType = col.AttributeOrdinal;
Version = col.Version;
}
(table as IGXPartialRead).GetStartEndTime(out starttm, out endtm);
System.Diagnostics.Debug.WriteLine("Reading table between: " + starttm.ToString() + "" + endtm.ToString());
data = parser.ReadRowsByRange(name, ClockLN, Gurux.DLMS.ObjectType.Clock, Version, starttm, endtm);
}
packet.AppendData(data);
}
else
{
throw new NotImplementedException();
}
}
/// <summary>
/// 如果没有找到对应的消息类型,返回 null
/// </summary>
/// <param name="msgType"></param>
/// <param name="eventType"></param>
/// <returns></returns>
public static Type GetMessageType(RequestTypes msgType, EventTypes? eventType)
{
return Types.Get(string.Format("{0},{1}", msgType, eventType), null);
}
/// <summary>
/// It's called on every request before sending it out to the server.
/// </summary>
HTTPRequest IConnection.PrepareRequest(HTTPRequest req, RequestTypes type)
{
if (req != null && AuthenticationProvider != null)
AuthenticationProvider.PrepareRequest(req, type);
if (RequestPreparator != null)
RequestPreparator(this, req, type);
return req;
}
public bool IsTransactionComplete(object sender, string command, GXPacket packet)
{
if (command == "IsAARQSend")
{
bool complete = AARQRequest.Length == AARQRequestPos;
return complete;
}
else if (command == "IsAllDataReceived")//Is all data read.
{
byte[] data = packet.ExtractPacket();
CheckErrors(data, false);
RequestTypes tmp = parser.GetDataFromPacket(data, ref ReceivedData);
if (tmp == RequestTypes.None && IsMoreDataAvailable != RequestTypes.None)
{
if ((IsMoreDataAvailable & RequestTypes.Frame) != 0)
{
IsMoreDataAvailable &= ~RequestTypes.Frame;
}
else
{
IsMoreDataAvailable &= ~RequestTypes.DataBlock;
}
}
else
{
IsMoreDataAvailable |= tmp;
}
return IsMoreDataAvailable == Gurux.DLMS.RequestTypes.None;
}
else if (command == "IsAllTableInfoReceived")//Is all data read.
{
byte[] data = packet.ExtractPacket();
CheckErrors(data, true);
RequestTypes tmp = parser.GetDataFromPacket(data, ref ReceivedData);
if (tmp == RequestTypes.None && IsMoreDataAvailable != RequestTypes.None)
{
if ((IsMoreDataAvailable & RequestTypes.Frame) != 0)
{
IsMoreDataAvailable &= ~RequestTypes.Frame;
}
else
{
IsMoreDataAvailable &= ~RequestTypes.DataBlock;
}
}
else
{
IsMoreDataAvailable |= tmp;
}
if (IsMoreDataAvailable != Gurux.DLMS.RequestTypes.None)
{
return true;
}
ExtraInfo[ExtraInfo.Keys.ElementAt(ExtraInfoPos)] = parser.GetValue(ReceivedData);
ReceivedData = null;
//Read next item.
if (++ExtraInfoPos < ExtraInfo.Count)
{
return false;
}
return true;
}
else if (command == "IsAllTableDataReceived")//Are all columns read.
{
Gurux.Device.GXTable table = sender as Gurux.Device.GXTable;
Gurux.Device.GXDevice device = table.Device;
int progress = 0;
byte[] data = packet.ExtractPacket();
CheckErrors(data, true);
//Clear packet so we are not saved it for later use.
packet.Clear();
RequestTypes tmp = parser.GetDataFromPacket(data, ref ReceivedData);
if (tmp == RequestTypes.None && IsMoreDataAvailable != RequestTypes.None)
{
if ((IsMoreDataAvailable & RequestTypes.Frame) != 0)
{
IsMoreDataAvailable &= ~RequestTypes.Frame;
}
else
{
IsMoreDataAvailable &= ~RequestTypes.DataBlock;
}
}
else
{
IsMoreDataAvailable |= tmp;
}
bool complete = IsMoreDataAvailable == Gurux.DLMS.RequestTypes.None;
//Notify only percent to increase traffic.
int maxValue = parser.GetMaxProgressStatus(ReceivedData);
//Notify progess.
if (maxValue == 0)
{
progress = 0;
}
else
{
double val = parser.GetCurrentProgressStatus(ReceivedData);
progress = (int)(val / maxValue * 100);
}
if (LastNotifiedTransactionProgress != progress)
{
if (complete)
{
device.NotifyTransactionProgress(this, new Gurux.Device.GXTransactionProgressEventArgs(sender, 100, 100, Gurux.Device.DeviceStates.ReadEnd));
}
else
{
device.NotifyTransactionProgress(this, new Gurux.Device.GXTransactionProgressEventArgs(sender, progress, 100, Gurux.Device.DeviceStates.ReadStart));
}
LastNotifiedTransactionProgress = progress;
}
//Try Parse DLMS objexts.
if (TryParse)
{
GXDLMSTable table2 = sender as GXDLMSTable;
if (this.ReceivedRows == 0)
{
table2.ClearRows();
}
Array reply = (Array)parser.TryGetValue(ReceivedData);
// If there is data.
if (reply != null && reply.Length != 0)
{
int count = pg.Buffer.Count;
pg.SetValue(2, reply);
List<object> receivedData = new List<object>(pg.Buffer.ToArray());
//Remove old rows. We must keep latest because some meters returns null as date time.
if (count != 0)
{
receivedData.RemoveRange(0, count);
pg.Buffer.RemoveRange(0, count - 1);
}
List<object[]> rows = new List<object[]>(receivedData.Count);
bool updated = false;
if (Extension != null)
{
updated = Extension.UpdateTableData(TableColumns, table2, reply, rows);
}
if (!updated)
{
foreach (object row in receivedData)
{
List<object> cols = new List<object>();
foreach (int it in ColumnIndexs)
{
cols.Add(((object[])row)[it]);
}
rows.Add(cols.ToArray());
}
}
table2.AddRows(-1, rows, false);
//Save latest read time. Note we must add Capture Period or we will read last values again.
Gurux.Device.Editor.IGXPartialRead partialRead = table as Gurux.Device.Editor.IGXPartialRead;
if (partialRead.Type == Gurux.Device.Editor.PartialReadType.New && rows[rows.Count - 1][0] is GXDateTime)
{
DateTime tm = (rows[rows.Count - 1][0] as GXDateTime).Value;
partialRead.Start = tm.AddSeconds(pg.CapturePeriod);
}
ReceivedRows += reply.Length;
}
}
return complete;
}
else
{
throw new NotImplementedException();
}
}
/// <summary>
/// Generates an acknowledgment message, with which the server is informed to
/// send next packets.
/// </summary>
/// <param name="type">Frame type</param>
/// <returns>Acknowledgment message as byte array.</returns>
public byte[] ReceiverReady(RequestTypes type)
{
if (!UseLogicalNameReferencing || type == RequestTypes.Frame)
{
byte id = GenerateSupervisoryFrame((byte)0);
byte id2 = GenerateACK();
if (id != id2)
{
//System.Diagnostics.Debug.WriteLine("TODO: " + id.ToString() + " " + id2.ToString());
}
return AddFrame(id, false, null, 0, 0);
}
List<byte> buff = new List<byte>(10);
if (this.InterfaceType == InterfaceType.General)
{
if (Server)
{
buff.AddRange(GXCommon.LLCReplyBytes);
}
else
{
buff.AddRange(GXCommon.LLCSendBytes);
}
}
//Get request normal
buff.Add(0xC0);
buff.Add(0x02);
//Invoke ID and priority.
buff.Add(GetInvokeIDPriority());
GXCommon.SetUInt32(PacketIndex, buff);
return AddFrame(GenerateIFrame(), false, buff, 0, buff.Count);
}
private ReportRequest ReportParse(RequestTypes.RequestTypeEnum requestType, string requestAction, XmlDocument doc)
{
ReportRequest reportRequest = new ReportRequest
{
RequestType = requestType,
RequestAction = requestAction,
XMLReturnCode = 0,
XMLReturnMessage = @"OK"
};
try
{
Guid requestGuid = Guid.Empty;
Guid.TryParse(ProcessNode(doc, "RequestID"), out requestGuid);
reportRequest.RequestID = requestGuid;
reportRequest.BusinessUnitID = ProcessNode(doc, "BusinessUnitID");
reportRequest.ReportParameters = ProcessNode(doc, "ReportParameters");
}
catch (Exception ex)
{
Utilities.WriteLog(String.Format(ex.Message + " " + ex.StackTrace));
reportRequest.ReturnType = ReturnTypes.ReturnTypeEnum.XmlError;
reportRequest.XMLReturnCode = -2;
reportRequest.XMLReturnMessage = ex.Message;
}
return reportRequest;
}
/// <summary>
/// Generates an acknowledgment message, with which the server is informed to
/// send next packets.
/// </summary>
/// <param name="type">Frame type</param>
/// <returns>Acknowledgment message as byte array.</returns>
public byte[] ReceiverReady(RequestTypes type)
{
return m_Base.ReceiverReady(type);
}
private RequestBodyBuilder PopulateRequestParameters(KnowledgebaseArticleRequest knowledgebaseArticleRequest, RequestTypes requestType)
{
knowledgebaseArticleRequest.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
parameters.AppendRequestDataNonEmptyString("subject", knowledgebaseArticleRequest.Subject);
parameters.AppendRequestDataNonEmptyString("contents", knowledgebaseArticleRequest.Contents);
if (requestType == RequestTypes.Create && knowledgebaseArticleRequest.CreatorId.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("creatorid", knowledgebaseArticleRequest.CreatorId.Value);
}
if (knowledgebaseArticleRequest.ArticleStatus.HasValue)
{
parameters.AppendRequestData("articlestatus", EnumUtility.ToApiString(knowledgebaseArticleRequest.ArticleStatus.Value));
}
parameters.AppendRequestDataBool("isfeatured", knowledgebaseArticleRequest.IsFeatured);
parameters.AppendRequestDataBool("allowcomments", knowledgebaseArticleRequest.AllowComments);
parameters.AppendRequestDataArrayCommaSeparated("categoryid", knowledgebaseArticleRequest.CategoryIds);
if (requestType == RequestTypes.Update && knowledgebaseArticleRequest.EditedStaffId.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("editedstaffid", knowledgebaseArticleRequest.EditedStaffId.Value);
}
return parameters;
}
/// <summary>
/// This method is used to test Request Type Enumeration related adapter requirements.
/// </summary>
/// <param name="instance">Specify the instance which need to be verified.</param>
/// <param name="site">Specify the ITestSite instance.</param>
private void VerifyRequestTypes(RequestTypes instance, ITestSite site)
{
// Directly capture requirement MS-FSSHTTPB_R176, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
176,
@"[In Request Type Enumeration][Request Type Enumeration] Specifies the sub-request type (section 2.2.2.1) to indicate the operation being requested, or the sub-response type (section 2.2.3.1) to indicate the response per the request.");
// Directly capture requirement MS-FSSHTTPB_R177, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
177,
@"[In Request Type Enumeration] The following table enumerates the values for each operation:[Its value must be one of 1,2,5,11].");
switch ((int)instance)
{
case 1:
// Directly capture requirement MS-FSSHTTPB_R178, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
178,
@"[In Request Type Enumeration][Request Type Enumeration is set to ]1 [specifies a request or response for the ]Query access[operation].");
// Directly capture requirement MS-FSSHTTPB_R863, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
863,
@"[In Query Access Sub-Request Processing] The server MUST reply back to the client with a Query Access sub-response, as specified in section 2.2.3.1.1.");
break;
case 2:
// Directly capture requirement MS-FSSHTTPB_R179, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
179,
@"[In Request Type Enumeration][Request Type Enumeration is set to ]2 [specifies a request or response for the ]Query changes[operation].");
// Directly capture requirement MS-FSSHTTPB_R865, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
865,
@"[In Query Changes Sub-Request Processing] The server MUST reply back to the client with a Query Changes sub-response, as specified in section 2.2.3.1.2. [<5>]");
break;
case 5:
// Directly capture requirement MS-FSSHTTPB_R182, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
182,
@"[In Request Type Enumeration][Request Type Enumeration is set to ]5 [specifies a request or response for the]Put changes[operation].");
// Directly capture requirement MS-FSSHTTPB_R872, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
872,
@"[In Put Changes Sub-Request Processing] The server MUST reply back to the client with a Put Changes sub-response, as specified in section 2.2.3.1.3.");
break;
case 11:
// Directly capture requirement MS-FSSHTTPB_R2097, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
2097,
@"[In Request Type Enumeration][Request Type Enumeration is set to ]11 [specifies a request or response for the] Allocate ExtendedGuid range[operation].");
break;
default:
site.Assert.Fail("Unsupported request types " + (int)instance);
break;
}
}
/// <summary>
/// Generates an acknowledgment message, with which the server is informed to
/// send next packets.
/// </summary>
/// <param name="type">Frame type</param>
/// <returns>Acknowledgment message as byte array.</returns>
public byte[] ReceiverReady(RequestTypes type)
{
if (!UseLogicalNameReferencing || type == RequestTypes.Frame)
{
return AddFrame(GenerateSupervisoryFrame((byte)0), false, null, 0, 0);
}
List<byte> buff = new List<byte>(10);
if (this.InterfaceType == InterfaceType.General)
{
if (Server)
{
buff.AddRange(GXCommon.LLCReplyBytes);
}
else
{
buff.AddRange(GXCommon.LLCSendBytes);
}
}
//Get request normal
buff.Add(0xC0);
buff.Add(0x02);
//Invoke ID and priority.
buff.Add(GetInvokeIDPriority());
GXCommon.SetUInt32(PacketIndex, buff);
return AddFrame(GenerateIFrame(), false, buff, 0, buff.Count);
}
private RequestBodyBuilder PopulateRequestParameters(TroubleshooterCategoryRequest troubleshooterCategoryRequest, RequestTypes requestType)
{
troubleshooterCategoryRequest.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
parameters.AppendRequestDataNonEmptyString("title", troubleshooterCategoryRequest.Title);
parameters.AppendRequestData("categorytype", EnumUtility.ToApiString(troubleshooterCategoryRequest.CategoryType));
if (requestType == RequestTypes.Create)
{
parameters.AppendRequestDataNonNegativeInt("staffid", troubleshooterCategoryRequest.StaffId);
}
if (troubleshooterCategoryRequest.DisplayOrder.HasValue)
{
parameters.AppendRequestDataNonNegativeInt("displayorder", troubleshooterCategoryRequest.DisplayOrder.Value);
}
parameters.AppendRequestDataNonEmptyString("description", troubleshooterCategoryRequest.Description);
parameters.AppendRequestDataBool("uservisibilitycustom", troubleshooterCategoryRequest.UserVisibilityCustom);
parameters.AppendRequestDataArrayCommaSeparated("usergroupidlist", troubleshooterCategoryRequest.UserGroupIdList);
parameters.AppendRequestDataBool("staffvisibilitycustom", troubleshooterCategoryRequest.StaffVisibilityCustom);
parameters.AppendRequestDataArrayCommaSeparated("staffgroupidlist", troubleshooterCategoryRequest.StaffGroupIdList);
return parameters;
}
private static RequestBodyBuilder PopulateRequestParameters(UserRequest user, RequestTypes requestType)
{
user.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
if (!String.IsNullOrEmpty(user.FullName))
{
parameters.AppendRequestData("fullname", user.FullName);
}
if (user.GroupId > 0)
{
parameters.AppendRequestData("usergroupid", user.GroupId);
}
if (user.EmailAddresses != null && user.EmailAddresses.Length > 0)
{
parameters.AppendRequestDataArray("email[]", user.EmailAddresses);
}
if (user.OrganizationId != null && user.OrganizationId.HasValue && user.OrganizationId.Value > 0)
{
parameters.AppendRequestData("userorganizationid", user.OrganizationId.Value);
}
parameters.AppendRequestData("salutation", EnumUtility.ToApiString(user.Salutation));
if(!String.IsNullOrEmpty(user.Designation))
{
parameters.AppendRequestData("designation", user.Designation);
}
if(!String.IsNullOrEmpty(user.Phone))
{
parameters.AppendRequestData("phone", user.Phone);
}
parameters.AppendRequestData("isenabled", Convert.ToInt32(user.IsEnabled));
parameters.AppendRequestData("userrole", EnumUtility.ToApiString(user.Role));
if(!String.IsNullOrEmpty(user.TimeZone))
{
parameters.AppendRequestData("timezone", user.TimeZone);
}
parameters.AppendRequestData("enabledst", Convert.ToInt32(user.EnableDst));
if (user.SlaPlanId != null)
{
parameters.AppendRequestData("slaplanid", user.SlaPlanId);
}
if (user.SlaPlanExpiry != null)
{
parameters.AppendRequestData("slaplanexpiry", user.SlaPlanExpiry);
}
if (user.Expiry != null)
{
parameters.AppendRequestData("userexpiry", user.Expiry);
}
return parameters;
}
private RequestBodyBuilder PopulateRequestParameters(TroubleshooterCommentRequest troubleshooterCommentRequest, RequestTypes requestType)
{
troubleshooterCommentRequest.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
parameters.AppendRequestDataNonNegativeInt("troubleshooterstepid", troubleshooterCommentRequest.TroubleshooterStepId);
parameters.AppendRequestDataNonEmptyString("contents", troubleshooterCommentRequest.Contents);
parameters.AppendRequestData("creatortype", EnumUtility.ToApiString(troubleshooterCommentRequest.CreatorType));
parameters.AppendRequestDataNonNegativeInt("creatorid", troubleshooterCommentRequest.CreatorId);
parameters.AppendRequestDataNonEmptyString("fullname", troubleshooterCommentRequest.FullName);
parameters.AppendRequestDataNonEmptyString("email", troubleshooterCommentRequest.Email);
parameters.AppendRequestDataNonNegativeInt("parentcommentid", troubleshooterCommentRequest.ParentCommentId);
return parameters;
}
private static RequestBodyBuilder PopulateRequestParameters(UserGroupRequest userGroup, RequestTypes requestType)
{
userGroup.EnsureValidData(requestType);
RequestBodyBuilder parameters = new RequestBodyBuilder();
if (!String.IsNullOrEmpty(userGroup.Title))
{
parameters.AppendRequestData("title", userGroup.Title);
}
parameters.AppendRequestData("grouptype", EnumUtility.ToApiString(userGroup.GroupType));
//parameters.AppendRequestData("ismaster", Convert.ToInt32(userGroup.Ismaster));
return parameters;
}
private bool GetLNData(List<byte> buff, ref int index, ref int pError, ref RequestTypes MoreData, byte res)
{
++index;
if (buff.Count - 1 < index)
{
return false;
}
//If meter returns exception.
if (res == 0xD8)
{
StateError StateError = (StateError) buff[index++];
ServiceError ServiceError = (ServiceError) buff[index++];
throw new GXDLMSException(StateError.ToString() + " " + ServiceError.ToString());
}
bool server = res == 0xC0;
server = this.Server;
if (res != 0x60 && res != 0x63 && res != (int)Command.GetResponse && res != (int)Command.SetResponse &&
res != (int)Command.SetRequest && res != (int)Command.GetRequest && res != (int)Command.MethodRequest &&
res != (int)Command.MethodResponse)
{
throw new GXDLMSException("Invalid response");
}
byte AttributeID = buff[index++];
if (buff.Count - 1 < index)
{
return false;
}
//Skip Invoke ID and priority.
byte InvokeID = buff[index++];
if (buff.Count - 1 < index)
{
return false;
}
if (server && AttributeID == 0x2)
{
MoreData |= RequestTypes.DataBlock;
}
else if (res == (int)Command.SetRequest)
{
}
else if (res == (int)Command.SetResponse || res == (int)Command.MethodResponse)
{
if (buff[index++] != 0)
{
pError = buff[index++];
}
}
else
{
if (server && AttributeID == 0x01)
{
}
else
{
byte Priority = buff[index++];
if (buff.Count - 1 < index)
{
return false;
}
if (AttributeID == 0x01 && Priority != 0)
{
if (buff.Count - 1 < index)
{
return false;
}
pError = buff[index++];
}
else
{
if (AttributeID == 0x02)
{
if (Priority == 0)
{
MoreData |= RequestTypes.DataBlock;
}
PacketIndex = GXCommon.GetUInt32(buff, ref index);
index += 1;
//Get data length.
int dataLength = GXCommon.GetObjectCount(buff, ref index);
}
}
}
}
return true;
}
/// <summary>
/// Prepares the request by adding two headers to it
/// </summary>
public void PrepareRequest(BestHTTP.HTTPRequest request, RequestTypes type)
{
request.SetHeader("username", this.User);
request.SetHeader("roles", this.Roles);
}
/// <summary>
/// Creates an Uri instance from the given parameters.
/// </summary>
Uri IConnection.BuildUri(RequestTypes type, TransportBase transport)
{
lock (SyncRoot)
{
// make sure that the queryBuilder is reseted
queryBuilder.Length = 0;
UriBuilder uriBuilder = new UriBuilder(Uri);
if (!uriBuilder.Path.EndsWith("/"))
uriBuilder.Path += "/";
this.RequestCounter %= UInt64.MaxValue;
switch (type)
{
case RequestTypes.Negotiate:
uriBuilder.Path += "negotiate";
goto default;
case RequestTypes.Connect:
#if !BESTHTTP_DISABLE_WEBSOCKET
if (transport != null && transport.Type == TransportTypes.WebSocket)
uriBuilder.Scheme = HTTPProtocolFactory.IsSecureProtocol(Uri) ? "wss" : "ws";
#endif
uriBuilder.Path += "connect";
goto default;
case RequestTypes.Start:
uriBuilder.Path += "start";
goto default;
case RequestTypes.Poll:
uriBuilder.Path += "poll";
if (this.LastReceivedMessage != null)
{
queryBuilder.Append("messageId=");
queryBuilder.Append(this.LastReceivedMessage.MessageId);
}
goto default;
case RequestTypes.Send:
uriBuilder.Path += "send";
goto default;
case RequestTypes.Reconnect:
#if !BESTHTTP_DISABLE_WEBSOCKET
if (transport != null && transport.Type == TransportTypes.WebSocket)
uriBuilder.Scheme = HTTPProtocolFactory.IsSecureProtocol(Uri) ? "wss" : "ws";
#endif
uriBuilder.Path += "reconnect";
if (this.LastReceivedMessage != null)
{
queryBuilder.Append("messageId=");
queryBuilder.Append(this.LastReceivedMessage.MessageId);
}
if (!string.IsNullOrEmpty(GroupsToken))
{
if (queryBuilder.Length > 0)
queryBuilder.Append("&");
queryBuilder.Append("groupsToken=");
queryBuilder.Append(GroupsToken);
}
goto default;
case RequestTypes.Abort:
uriBuilder.Path += "abort";
goto default;
case RequestTypes.Ping:
uriBuilder.Path += "ping";
queryBuilder.Append("&tid=");
queryBuilder.Append(this.RequestCounter++.ToString());
queryBuilder.Append("&_=");
queryBuilder.Append(Timestamp.ToString());
break;
default:
if (queryBuilder.Length > 0)
queryBuilder.Append("&");
queryBuilder.Append("tid=");
queryBuilder.Append(this.RequestCounter++.ToString());
queryBuilder.Append("&_=");
queryBuilder.Append(Timestamp.ToString());
if (transport != null)
{
queryBuilder.Append("&transport=");
queryBuilder.Append(transport.Name);
}
queryBuilder.Append("&clientProtocol=");
queryBuilder.Append(ClientProtocol);
if (NegotiationResult != null && !string.IsNullOrEmpty(this.NegotiationResult.ConnectionToken))
{
queryBuilder.Append("&connectionToken=");
queryBuilder.Append(this.NegotiationResult.ConnectionToken);
}
if (this.Hubs != null && this.Hubs.Length > 0)
{
queryBuilder.Append("&connectionData=");
queryBuilder.Append(this.ConnectionData);
}
break;
}
// Query params are added to all uri
if (this.AdditionalQueryParams != null && this.AdditionalQueryParams.Count > 0)
queryBuilder.Append(this.QueryParams);
uriBuilder.Query = queryBuilder.ToString();
// reset the string builder
queryBuilder.Length = 0;
return uriBuilder.Uri;
}
}
public RequestTypeAttribute(RequestTypes msgType, EventTypes eventType)
{
this.MessageType = msgType;
this.EventType = eventType;
}
