/// <summary>
/// Gets the rules of the server
/// </summary>
/// <returns>RuleResponse containing all rules as a Dictionary</returns>
/// <exception cref="SourceQueryException"></exception>
public RuleResponse GetRules(int maxRetries = 10)
{
try
{
var byteReader = RequestDataFromServer(Constants.A2S_RULES_CHALLENGE_REQUEST, out byte header, maxRetries, true);
if (!header.Equals(Constants.A2S_RULES_RESPONSE))
{
throw new ArgumentException("Response was no rules response.");
}
RuleResponse ruleResponse = new RuleResponse()
{
Header = header, Rules = new Dictionary <string, string>()
};
int rulecount = byteReader.GetShort();
for (int i = 1; i <= rulecount; i++)
{
ruleResponse.Rules.Add(byteReader.GetString(), byteReader.GetString());
}
return(ruleResponse);
}
catch (Exception ex)
{
throw new SourceQueryException("Could not gather Rules", ex);
}
}
private SonarQubeRule ToSonarQubeRule(RuleResponse response,
IEnumerable <QualityProfileResponse> activeQualityProfiles)
{
var isActive = activeQualityProfiles.Any();
SonarQubeIssueSeverity severity;
Dictionary <string, string> parameters;
if (isActive)
{
var activeQP = activeQualityProfiles.First();
severity = SonarQubeIssueSeverityConverter.Convert(activeQP.Severity);
// Optimisation: avoid creating objects if there are no parameters
parameters = activeQP.Parameters.Length > 0 ?
activeQP.Parameters.ToDictionary(p => p.Key, p => p.Value) : null;
}
else
{
severity = SonarQubeIssueSeverity.Unknown;
parameters = null;
}
var issueType = SonarQubeIssueTypeConverter.Convert(response.Type);
return(new SonarQubeRule(GetRuleKey(response.Key), response.RepositoryKey, isActive, severity, parameters, issueType));
}
public void Calling_process_action_with_a_process_rule_response_request_for_an_in_flight_contract_with_no_triggered_actions_should_progress_the_trade_to_approved()
{
var processor = GetProcessor(true);
var currentContract = new Contract();
var contractRequest = ProcessContractRequest.New(currentContract);
var trackingRefernence = contractRequest.Payload.TrackingReference;
var processResponse = processor.ProcessAction(contractRequest).Result;
AwaitAssert(() => {
Assert.IsNotNull(_contractPersistence.GetContractTrackingReference(trackingRefernence));
Assert.IsTrue(_responseObserver.Responses.Any(r => (r.Request as IActionRequest)?.Context.OriginatingRequest == contractRequest && r.GetStateChange().NewState.CurrentState == "IsPendingApproval"));
},
assertTimeout, assertInterval);
var ruleResponse = new RuleResponse {
TriggeredActions = new List <TriggeredAction>()
};
var ruleRequest = ProcessRuleResponseRequest.New(currentContract, ruleResponse, trackingRefernence);
processResponse = processor.ProcessAction(ruleRequest).Result;
AwaitAssert(() => {
Assert.IsTrue(_responseObserver.Responses.Any(r => (r.Request as IActionRequest)?.Context.OriginatingRequest == contractRequest && r.GetStateChange().NewState.CurrentState == "IsNotPendingResubmit"));
},
assertTimeout, assertInterval);
}
public void ProcessLearningToSkiOrderTest()
{
OrderDetails od = new OrderDetails();
od.OrderType = OrderType.LEARNING_TO_SKI;
od.UserEmail = "*****@*****.**";
HandleOrder obj = new HandleOrder();
RuleResponse upgradeMemberShipOrder = obj.handleOrder(od);
Assert.AreNotEqual(null, od);
Assert.AreEqual(true, upgradeMemberShipOrder.LearnToSki);
}
public void ProcessUpgradeMembershipOrderTest()
{
OrderDetails od = new OrderDetails();
od.OrderType = OrderType.UPGRADE_MEMBERSHIP;
od.UserEmail = "*****@*****.**";
HandleOrder obj = new HandleOrder();
RuleResponse upgradeMemberShipOrder = obj.handleOrder(od);
Assert.AreNotEqual(null, od);
Assert.AreEqual(true, upgradeMemberShipOrder.UpgradeMembership);
}
public void ProcessBookOrderTest()
{
OrderDetails od = new OrderDetails();
od.OrderType = OrderType.BOOK;
od.UserEmail = "*****@*****.**";
HandleOrder obj = new HandleOrder();
RuleResponse bookOrdered = obj.handleOrder(od);
Assert.AreNotEqual(null, od);
Assert.AreEqual(true, bookOrdered.BookOrder);
}
public void ProcessPhysicalProductOrderComissionSentTest()
{
OrderDetails od = new OrderDetails();
od.OrderType = OrderType.PHYSICAL_PRODUCT;
od.UserEmail = "*****@*****.**";
od.AgentContact = "myAgent";
HandleOrder obj = new HandleOrder();
RuleResponse physicalProductOrder = obj.handleOrder(od);
Assert.AreNotEqual(null, od);
Assert.AreEqual(true, physicalProductOrder.ComissionCredited);
}
public RuleResponse Evaluate(Card active, Card played)
{
RuleResponse response = new RuleResponse();
if (active.Suit == played.Suit || active.Value == played.Value)
{
response.Response = RuleResponse.ResponseType.Legal;
response.Message = "The move is legal";
}
else
{
response.Response = RuleResponse.ResponseType.Illegal;
response.Message = "Incorrect play";
}
return(response);
}
public void Calling_process_action_with_a_process_workflow_response_request_for_an_in_flight_contract_with_triggered_actions_should_leave_the_contract_pending_approval_unless_all_actions_are_approved()
{
var processor = GetProcessor(true);
var currentContract = new Contract();
var contractRequest = ProcessContractRequest.New(currentContract);
var trackingRefernence = contractRequest.Payload.TrackingReference;
var processResponse = processor.ProcessAction(contractRequest).Result;
AwaitAssert(() => {
Assert.IsNotNull(_contractPersistence.GetContractTrackingReference(trackingRefernence));
Assert.IsTrue(_responseObserver.Responses.Any(r => (r.Request as IActionRequest)?.Context.OriginatingRequest == contractRequest && r.GetStateChange().NewState.CurrentState == "IsPendingApproval"));
},
assertTimeout, assertInterval);
var ruleResponse = new RuleResponse
{
TriggeredActions = new List <TriggeredAction>()
{
new TriggeredAction {
ActionReference = Guid.NewGuid()
},
new TriggeredAction {
ActionReference = Guid.NewGuid()
}
}
};
var ruleRequest = ProcessRuleResponseRequest.New(currentContract, ruleResponse, trackingRefernence);
processResponse = processor.ProcessAction(ruleRequest).Result;
AwaitAssert(() => {
Assert.IsTrue(_responseObserver.Responses.Any(r => (r.Request as IActionRequest)?.Context.OriginatingRequest == ruleRequest && r.GetStateChange().NewState.CurrentState == "IsPendingApproval"));
},
assertTimeout, assertInterval);
var workflowResponse = new WorkflowResponse
{
ActionReference = ruleResponse.TriggeredActions.First().ActionReference,
ActionState = Domain.ActionState.Approved
};
var workflowRequest = ProcessWorkflowResponseRequest.New(currentContract, workflowResponse, trackingRefernence);
processResponse = processor.ProcessAction(workflowRequest).Result;
}
public async Task <RuleResponse> DeleteAsync(int code)
{
try
{
var exist = await _ruleRepository.FindByIdAsync(code);
RuleResponse response = exist == null ? new RuleResponse($"Rule {code} not found") : new RuleResponse(exist);
_ruleRepository.Remove(exist);
await _unitOfWork.CompleteAsync();
return(response);
}
catch (Exception e)
{
return(new RuleResponse($"An error occurred when deleting the rule: { e.Message }"));
}
}
/// <summary>
/// Checks the new request.
/// </summary>
/// <param name="requestId">The request identifier.</param>
/// <param name="briefingRequest">The briefing request.</param>
/// <returns>Rule Response Message</returns>
public RuleResponse CheckNewRequest(decimal requestId, BriefingRequestViewModel briefingRequest)
{
bool duplicateDefaultAddress = false;
RuleResponse response = new RuleResponse()
{
Result = true
};
// Process for assign error error
if (duplicateDefaultAddress)
{
///// use common repository class BriefingRequestCommonRepository to get data
// response.Result = false;
// response.RuleErrors.ValidationHeaderMessage = "Duplicate Default Customer Address";
// response.RuleErrors.TryAdd("CustomerAddress", new List<string> { "Customer default address had been modified by other users and only one address can be default, please refresh and try again" });
}
return(response);
}
public async Task <RuleResponse> UpdateAsync(int code, Rule rule)
{
try
{
var exist = await _ruleRepository.FindByIdAsync(code);
RuleResponse response = exist == null ? new RuleResponse($"Rule {code} not found") : new RuleResponse(exist);
exist.Type = rule.Type != "" ? rule.Type : exist.Type;
exist.Description = rule.Description != "" ? rule.Description : exist.Description;
_ruleRepository.Update(exist);
await _unitOfWork.CompleteAsync();
return(response);
}
catch (Exception e)
{
return(new RuleResponse($"An error occurred when updating the rule: { e.Message }"));
}
}
/// <summary>
/// The ButtonAdd_Click method.
/// </summary>
/// <param name="sender">The <paramref name="sender"/> parameter.</param>
/// <param name="args">The <paramref name="args"/> parameter.</param>
private void ButtonAdd_Click(object sender, EventArgs args)
{
var lvItem = new ListViewItem(string.Empty);
var newRuleResponse = new RuleResponse();
if (rbCustomScript.Checked)
{
newRuleResponse.IsCustomScript = true;
newRuleResponse.Script = tbxScript.Text;
lvItem.SubItems.Add($"Custom Script: {newRuleResponse.Script}");
}
else
{
newRuleResponse.IsCustomScript = false;
newRuleResponse.SituationType = tbxSituationType.Text;
if (chbxSeverity.Checked)
{
newRuleResponse.UsedSourceEventFields.Add("severity");
}
if (chbxSourceDeviceId.Checked)
{
newRuleResponse.UsedSourceEventFields.Add("source_device_id");
}
if (chbxProperties.Checked)
{
newRuleResponse.UsedSourceEventFields.Add("properties");
}
lvItem.SubItems.Add($"Generate Event: {newRuleResponse.SituationType}");
}
lvItem.Tag = newRuleResponse;
ResponseListView.Items.Add(lvItem);
}
public static ProcessRuleResponseRequest New(Contract contract, RuleResponse ruleResponse, Guid trackingReference) => new ProcessRuleResponseRequest(new RuleResponseProcessingPayload(contract, ruleResponse, trackingReference));
static void Main(string[] args)
{
//Initialize Samart API using clientcode and password.
string Client_code = ""; //YOUR CLIENT CODE
string Password = ""; //YOUR PASSWORD
string api_key = "";
string JWTToken = ""; // optional
string RefreshToken = ""; // optional
SmartApi connect = new SmartApi(api_key, JWTToken, RefreshToken);
OutputBaseClass obj = new OutputBaseClass();
//Login by client code and password
obj = connect.GenerateSession(Client_code, Password);
AngelToken agr = obj.TokenResponse;
Console.WriteLine("------GenerateSession call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(agr));
Console.WriteLine("----------------------------------------------");
//Get Token
obj = connect.GenerateToken();
agr = obj.TokenResponse;
Console.WriteLine("------GenerateToken call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(agr));
Console.WriteLine("----------------------------------------------");
//Get Profile
obj = connect.GetProfile();
GetProfileResponse gp = obj.GetProfileResponse;
Console.WriteLine("------GetProfile call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(gp));
Console.WriteLine("----------------------------------------------");
//Place Order
OrderInfo ord = new OrderInfo();
ord.variety = Constants.VARIETY_NORMAL;
ord.tradingsymbol = "SBIN-EQ";
ord.symboltoken = "3045";
ord.transactiontype = Constants.TRANSACTION_TYPE_BUY;
ord.exchange = Constants.EXCHANGE_NSE;
ord.ordertype = Constants.ORDER_TYPE_LIMIT;
ord.producttype = Constants.PRODUCT_TYPE_INTRADAY;
ord.duration = Constants.VALIDITY_DAY.ToString();
ord.price = "350.00";
ord.squareoff = "0";
ord.stoploss = "0";
ord.quantity = "10";
ord.triggerprice = "0"; //OPTIONAL PARAMETER
//ord.triggerprice = "350"; //OPTIONAL PARAMETER
obj = connect.placeOrder(ord);
OrderResponse Ores = obj.PlaceOrderResponse;
Console.WriteLine("------placeOrder call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(Ores));
Console.WriteLine("----------------------------------------------");
//Modify Order
OrderInfo mord = new OrderInfo();
mord.orderid = "211029001245777";
mord.variety = Constants.VARIETY_NORMAL;
mord.tradingsymbol = "SBIN-EQ";
mord.symboltoken = "3045";
mord.transactiontype = Constants.TRANSACTION_TYPE_BUY;
mord.exchange = Constants.EXCHANGE_NSE;
mord.ordertype = Constants.ORDER_TYPE_LIMIT;
mord.producttype = Constants.PRODUCT_TYPE_DELIVERY;
mord.duration = Constants.VALIDITY_DAY.ToString();
mord.price = "340.00";
mord.squareoff = "0";
mord.stoploss = "0";
mord.quantity = "20";
mord.triggerprice = "0"; //OPTIONAL PARAMETER
//mord.triggerprice = "357"; //OPTIONAL PARAMETER
obj = connect.modifyOrder(mord);
OrderResponse mOres = obj.ModifyOrderResponse;
Console.WriteLine("------modifyOrder call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(mOres));
Console.WriteLine("----------------------------------------------");
//cancel Order
OrderInfo ord2 = new OrderInfo();
ord2.orderid = "211029001245777";
ord2.variety = Constants.VARIETY_NORMAL;
obj = connect.cancelOrder(ord2);
OrderResponse cOrs = obj.CancelOrderResponse;
Console.WriteLine("------cancelOrder call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(cOrs));
Console.WriteLine("----------------------------------------------");
//get Order Book
obj = connect.getOrderBook();
GetOrderBookResponse book = obj.GetOrderBookResponse;
Console.WriteLine("------getOrderBook call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(book));
Console.WriteLine("----------------------------------------------");
//get Trade Book
obj = connect.getTradeBook();
GetTradeBookResponse trade = obj.GetTradeBookResponse;
Console.WriteLine("------getTradeBook call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(trade));
Console.WriteLine("----------------------------------------------");
// Get Get LTP Data
LTPDataRequest lreq = new LTPDataRequest();
lreq.exchange = Constants.EXCHANGE_NSE;
lreq.symboltoken = "3045";
lreq.tradingsymbol = "SBIN-EQ";
obj = connect.GetLTPData(lreq);
GetLTPDataResponse ltp = obj.GetLTPDataResponse;
Console.WriteLine("------GetLTPData call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(ltp));
Console.WriteLine("----------------------------------------------");
//get Holding
obj = connect.getHolding();
GetHoldingResponse holding = obj.GetHoldingResponse;
Console.WriteLine("------getHolding call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(holding));
Console.WriteLine("----------------------------------------------");
//get Position
obj = connect.getPosition();
GetPositionResponse position = obj.GetPositionResponse;
Console.WriteLine("------getPosition call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(position));
Console.WriteLine("----------------------------------------------");
//Convert Position
ConvertPositionRequest req = new ConvertPositionRequest();
req.exchange = Constants.EXCHANGE_NSE.ToString();
req.oldproducttype = Constants.PRODUCT_TYPE_DELIVERY;
req.newproducttype = Constants.PRODUCT_TYPE_MARGIN;
req.tradingsymbol = "SBIN-EQ";
req.transactiontype = Constants.TRANSACTION_TYPE_BUY;
req.quantity = 1;
req.type = Constants.VALIDITY_DAY;
obj = connect.convertPosition(req);
PositionConversionResponse cc = obj.PositionConversionResponse;
Console.WriteLine("------convertPosition call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(cc));
Console.WriteLine("----------------------------------------------");
//get RMS
obj = connect.getRMS();
GetRMSLimitResponse gmres = obj.GetRMSLimitResponse;
Console.WriteLine("------getRMS call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(gmres));
Console.WriteLine("----------------------------------------------");
//Create Rule
CreateRuleRequest crreq = new CreateRuleRequest();
//crreq.id = 0;
crreq.tradingsymbol = "SBIN-EQ";
crreq.symboltoken = "3045";
crreq.exchange = Constants.EXCHANGE_NSE;
crreq.transactiontype = Constants.TRANSACTION_TYPE_BUY;
crreq.producttype = Constants.PRODUCT_TYPE_MARGIN;
crreq.price = "350";
crreq.qty = "10";
crreq.triggerprice = "370";
crreq.disclosedqty = "10";
crreq.timeperiod = "20";
obj = connect.CreateRule(crreq);
RuleResponse rr = obj.CreateRuleResponse;
Console.WriteLine("------CreateRule call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(rr));
Console.WriteLine("----------------------------------------------");
//Rule Details
string RuleID = "1000118";
obj = connect.ruleDetails(RuleID);
RuleDetailsResponse rd = obj.RuleDetailsResponse;
Console.WriteLine("------ruleDetails call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(rd));
Console.WriteLine("----------------------------------------------");
//Modify Rule
CreateRuleRequest crreq2 = new CreateRuleRequest();
crreq2.id = "1000118";
crreq2.tradingsymbol = "SBIN-EQ";
crreq2.symboltoken = "3045";
crreq2.exchange = Constants.EXCHANGE_NSE;
crreq2.transactiontype = Constants.TRANSACTION_TYPE_BUY;
crreq2.producttype = Constants.PRODUCT_TYPE_MARGIN;
crreq2.price = "350";
crreq2.qty = "10";
crreq2.triggerprice = "360";
crreq2.disclosedqty = "10";
crreq2.timeperiod = "20";
obj = connect.modifyRule(crreq2);
RuleResponse rm = obj.ModifyRuleResponse;
Console.WriteLine("------modifyRule call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(rm));
Console.WriteLine("----------------------------------------------");
//Cancel Rule
CancelRuleRequest creq = new CancelRuleRequest();
creq.id = "1000117";
creq.symboltoken = "3045";
creq.exchange = Constants.EXCHANGE_NSE;
obj = connect.cancelRule(creq);
RuleResponse rc = obj.CancelRuleResponse;
Console.WriteLine("------cancelRule call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(rc));
Console.WriteLine("----------------------------------------------");
//Rule List
RuleListRequest rreq = new RuleListRequest();
rreq.status = new List <string>();
rreq.status.Add("NEW");
rreq.status.Add("CANCELLED");
rreq.page = 1;
rreq.count = 10;
obj = connect.ruleList(rreq);
RuleListResponse rl = obj.RuleListResponse;
Console.WriteLine("------ruleList call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(rl));
Console.WriteLine("----------------------------------------------");
//Get Candle Data
CandleRequest cdreq = new CandleRequest();
cdreq.exchange = Constants.EXCHANGE_NSE;
cdreq.symboltoken = "3045";
cdreq.interval = Constants.INTERVAL_MINUTE;
cdreq.fromdate = "2021-02-08 09:00";
cdreq.todate = "2021-02-08 09:15";
obj = connect.GetCandleData(cdreq);
CandleDataResponse cd = obj.GetCandleDataResponse;
Console.WriteLine("------GetCandleData call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(cd));
Console.WriteLine("----------------------------------------------");
//LogOut
obj = connect.LogOut(Client_code);
LogOutResponse lg = obj.LogOutResponse;
Console.WriteLine("------LogOut call output-------------");
Console.WriteLine(JsonConvert.SerializeObject(lg));
Console.WriteLine("----------------------------------------------");
}
public RuleResponseProcessingPayload(Contract contract, RuleResponse ruleResponse, Guid trackingReference)
: base(contract, trackingReference)
{
RuleResponse = ruleResponse;
}
async Task <IEnumerable <RuleResponse> > getRulesForParameters(int[] parameterIds)
{
var rules = new List <RuleResponse>();
var ruleIds = new List <int>();
//get all parameters
var allDisallowedParameters = new List <DisallowedParameter>();
foreach (var parameterId in parameterIds)
{
var fetchedParameters = await _context.DisallowedParameter
.Where(rule => rule.ParameterId == parameterId)
.ToListAsync();
allDisallowedParameters.AddRange(fetchedParameters);
}
//get all rule names
var allDisallowedRuleNames = new List <DisallowedRule>();
foreach (var disallowedParameter in allDisallowedParameters)
{
var fetchedRuleNames = await _context.DisallowedRule
.Where(rule => rule.ObjectId == disallowedParameter.DisallowedRuleId)
.ToListAsync();
allDisallowedRuleNames.AddRange(fetchedRuleNames);
}
//get all rule values
var allDisallowedRuleValues = new List <DisallowedValue>();
foreach (var disallowedParameter in allDisallowedParameters)
{
var fetchedRuleValues = await _context.DisallowedValue
.Where(value => value.DisallowedParameterId == disallowedParameter.ParameterId)
.ToListAsync();
allDisallowedRuleValues.AddRange(fetchedRuleValues);
}
//remove duplicates
var disallowedRuleNames = allDisallowedRuleNames.Distinct().ToList();
//add rules
foreach (var disallowedRule in disallowedRuleNames)
{
//create value list
var incompatableValues = new List <ParameterValueResponse>();
//get all parameter with rule id
var ruleParameters = allDisallowedParameters.FindAll(p => p.DisallowedRuleId == disallowedRule.ObjectId);
foreach (var param in ruleParameters)
{
//get all values with param ids
var ruleValues = allDisallowedRuleValues.FindAll(v => v.DisallowedParameterId == param.ParameterId);
System.Console.WriteLine("{0}, param {1}, have {2} conflicting values", disallowedRule.Name, param.ParameterId, ruleValues.Count);
foreach (var value in ruleValues)
{
if (!incompatableValues.Exists(v => v.id == value.ParameterValueId))
{
//add values
var valueResponse = new ParameterValueResponse {
id = value.ParameterValueId,
parameterId = value.DisallowedParameterId,
name = null
};
incompatableValues.Add(valueResponse);
}
}
}
//map rules
var rule = new RuleResponse {
id = disallowedRule.ObjectId,
name = disallowedRule.Name,
incompatableValues = incompatableValues.ToArray(),
};
rules.Add(rule);
System.Console.WriteLine("");
}
return(rules);
}
