public void SetHasParameter(bool hasParameter, ActuatorStaticDataCollection staticDataController = null)
{
if (staticDataController != null)
{
ActuatorStaticDataController = new FiddlerActuatorStaticDataCollectionController(staticDataController);
}
IsHasParameter = hasParameter;
if (IsRawReplace)
{
if (HttpRawRequest != null)
{
HttpRawRequest.SetUseParameterInfo(IsHasParameter, ActuatorStaticDataController.actuatorStaticDataCollection);
}
}
else
{
if (UriModific != null && UriModific.ModificMode != ContentModificMode.NoChange)
{
UriModific.SetUseParameterInfo(IsHasParameter, ActuatorStaticDataController.actuatorStaticDataCollection);
}
if (BodyModific != null && BodyModific.ModificMode != ContentModificMode.NoChange)
{
BodyModific.SetUseParameterInfo(IsHasParameter, ActuatorStaticDataController.actuatorStaticDataCollection);
}
}
}
public ParameterContentModific(string targetKey, string replaceContent, ActuatorStaticDataCollection dataCollection, bool useParameter) : base(targetKey, replaceContent)
{
ParameterTargetKey = new CaseParameterizationContent(targetKey, useParameter);
ParameterReplaceContent = new CaseParameterizationContent(replaceContent, useParameter);
actuatorStaticDataCollection = dataCollection;
IsUseParameter = useParameter;
}
internal StaticDataAddWindow(ActuatorStaticDataCollection yourActuatorStaticDataCollection, int yourIndex, Action <FreeHttp.FreeHttpControl.StaticDataManageWindow.ShowRunTimeParameterType> yourShowInfoChange)
{
InitializeComponent();
actuatorStaticDataCollection = yourActuatorStaticDataCollection;
startIndex = yourIndex;
ShowInfoChange = yourShowInfoChange;
}
private void StaticDataManageWindow_FormClosing(object sender, FormClosingEventArgs e)
{
if (actuatorStaticDataCollection != null)
{
actuatorStaticDataCollection.OnChangeCollection -= actuatorStaticDataCollection_OnChangeCollection;
actuatorStaticDataCollection = null;
}
}
private void FreeHttpWindow_Load(object sender, EventArgs e)
{
try
{
LoadFiddlerModificHttpRuleCollection(fiddlerModificHttpRuleCollection);
}
catch (Exception ex)
{
MessageBox.Show(string.Format("{0}\r\n{1}", ex.Message, ex.InnerException == null? "":ex.InnerException.Message), "load user rule fail");
if (File.Exists("RuleData.xml"))
{
File.Copy("RuleData.xml", "RuleData.lastErrorFile", true);
}
}
if (StaticDataCollection == null)
{
StaticDataCollection = new ActuatorStaticDataCollection(true);
}
if (ModificSettingInfo == null)
{
ModificSettingInfo = new FiddlerModificSettingInfo(false, true, true);
}
if (ModificSettingInfo.IsDefaultEnableRule)
{
pb_requestRuleSwitch_Click(null, null);
pb_responseRuleSwitch_Click(null, null);
}
FreeHttp.MyHelper.MyGlobalHelper.OnGetGlobalMessage += ((obj, arg) => { PutWarn(arg.Message); });
tbe_RequestBodyModific.Visible = false;
tbe_ResponseBodyModific.Visible = false;
tbe_urlFilter.Visible = false;
tbe_RequestBodyModific.OnCloseEditBox += tbe_BodyModific_OnCloseEditBox;
tbe_ResponseBodyModific.OnCloseEditBox += tbe_BodyModific_OnCloseEditBox;
tbe_urlFilter.OnCloseEditBox += tbe_BodyModific_OnCloseEditBox;
cb_macthMode.SelectedIndex = 0;
tabControl_Modific.SelectedIndex = 0;
IsSetResponseLatencyEable = false;
//rtb_MesInfo.AllowDrop = true;
//rtb_MesInfo.DragEnter += rtb_MesInfo_DragEnter;
//rtb_MesInfo.DragDrop += rtb_MesInfo_DragDrop;
splitContainer_httpEditInfo.AllowDrop = true;
splitContainer_httpEditInfo.DragEnter += rtb_MesInfo_DragEnter;
splitContainer_httpEditInfo.DragDrop += rtb_MesInfo_DragDrop;
panel_modific_Contorl.AllowDrop = true;
panel_modific_Contorl.DragEnter += rtb_MesInfo_DragEnter;
panel_modific_Contorl.DragDrop += rtb_MesInfo_DragDrop;
MyControlHelper.SetRichTextBoxDropString(rtb_requsetReplace_body);
MyControlHelper.SetRichTextBoxDropString(rtb_requestRaw);
}
public StaticDataManageWindow(ActuatorStaticDataCollection yourActuatorStaticDataCollection)
{
InitializeComponent();
actuatorStaticDataCollection = yourActuatorStaticDataCollection;
if (yourActuatorStaticDataCollection != null)
{
actuatorStaticDataCollection.OnChangeCollection += actuatorStaticDataCollection_OnChangeCollection;
}
}
public void SetUseParameterInfo(bool isUseParameter, ActuatorStaticDataCollection staticDataCollection = null)
{
IsUseParameter = isUseParameter;
ParameterTargetKey.hasParameter = IsUseParameter;
ParameterReplaceContent.hasParameter = IsUseParameter;
if (IsUseParameter && staticDataCollection != null)
{
actuatorStaticDataCollection = staticDataCollection;
}
}
public ParameterHttpResponse GetHttpResponse(ActuatorStaticDataCollection yourActuatorStaticDataCollection)
{
ParameterHttpResponse nowHttpResponse = ParameterHttpResponse.GetHttpResponse(rtb_rawResponse.Text.Replace("\n", "\r\n"), IsUseParameterData, yourActuatorStaticDataCollection);
if (ContentLengthToolStripMenuItem.Checked)
{
nowHttpResponse.SetAutoContentLength();
}
return(nowHttpResponse);
}
private void SaveShareRule()
{
List <FiddlerRequestChange> nowFiddlerRequestChangeRuleList = new List <FiddlerRequestChange>();
List <FiddlerResponseChange> nowFiddlerResponseChangeRuleList = new List <FiddlerResponseChange>();
ActuatorStaticDataCollection nowStaticDataCollection = new ActuatorStaticDataCollection();
// new WebService.RuleReportService().UploadRulesAsync<FiddlerRequestChange, FiddlerResponseChange>(FiddlerRequestChangeRuleList, FiddlerResponseChangeRuleList , StaticDataCollection).Wait();
if (lv_remote_requestRuleList.CheckedItems != null && lv_remote_requestRuleList.CheckedItems.Count > 0)
{
foreach (ListViewItem requestItem in lv_remote_requestRuleList.CheckedItems)
{
if (!(requestItem.Tag is FiddlerRequestChange))
{
MessageBox.Show("data error");
_ = RemoteLogService.ReportLogAsync("requestItem.Tag is not FiddlerRequestChange", RemoteLogService.RemoteLogOperation.ShareRule, RemoteLogService.RemoteLogType.Error);
return;
}
nowFiddlerRequestChangeRuleList.Add(requestItem.Tag as FiddlerRequestChange);
}
}
if (lv_remote_responseRuleList.CheckedItems != null && lv_remote_responseRuleList.CheckedItems.Count > 0)
{
foreach (ListViewItem reponseItem in lv_remote_responseRuleList.CheckedItems)
{
if (!(reponseItem.Tag is FiddlerResponseChange))
{
MessageBox.Show("data error");
_ = RemoteLogService.ReportLogAsync("requestItem.Tag is not FiddlerRequestChange", RemoteLogService.RemoteLogOperation.ShareRule, RemoteLogService.RemoteLogType.Error);
return;
}
nowFiddlerResponseChangeRuleList.Add(reponseItem.Tag as FiddlerResponseChange);
}
}
if (nowFiddlerRequestChangeRuleList.Count == 0 && nowFiddlerResponseChangeRuleList.Count == 0)
{
MessageBox.Show("Please check the rules you want to share", "stop");
MyHelper.MyGlobalHelper.markControlService.MarkControl(lv_remote_requestRuleList, System.Drawing.Color.Pink, 2);
MyHelper.MyGlobalHelper.markControlService.MarkControl(lv_remote_responseRuleList, System.Drawing.Color.Pink, 2);
return;
}
shareRuleService.NowSaveRuleDetails = new RuleDetails()
{
ModificHttpRuleCollection = new FiddlerModificHttpRuleCollection(nowFiddlerRequestChangeRuleList, nowFiddlerResponseChangeRuleList),
StaticDataCollection = localRuleDetails.StaticDataCollection
};
FreeHttp.FreeHttpControl.SaveShareRule saveShareRuleWindow = new SaveShareRule(shareRuleService);
saveShareRuleWindow.Owner = this;
saveShareRuleWindow.StartPosition = FormStartPosition.CenterParent;
saveShareRuleWindow.ShowDialog();
return;
}
/// <summary>
/// FreeHttpWindow
/// </summary>
/// <param name="yourRuleCollection">the history rule</param>
public FreeHttpWindow(FiddlerModificHttpRuleCollection yourRuleCollection, FiddlerModificSettingInfo yourModifcSettingInfo, ActuatorStaticDataCollection yourStaticDataCollection)
: this()
{
fiddlerModificHttpRuleCollection = yourRuleCollection;
ModificSettingInfo = yourModifcSettingInfo;
StaticDataCollection = yourStaticDataCollection;
if (fiddlerModificHttpRuleCollection != null && StaticDataCollection != null)
{
foreach (var fr in fiddlerModificHttpRuleCollection.ResponseRuleList)
{
fr.ActuatorStaticDataController = new FiddlerActuatorStaticDataCollectionController(StaticDataCollection);
if (fr.IsRawReplace)
{
if (fr.HttpRawResponse.ParameterizationContent == null)
{
fr.HttpRawResponse.ParameterizationContent = new AutoTest.ParameterizationContent.CaseParameterizationContent(fr.HttpRawResponse.OriginSting);
}
fr.HttpRawResponse.SetActuatorStaticDataCollection(StaticDataCollection);
}
}
foreach (var fr in fiddlerModificHttpRuleCollection.RequestRuleList)
{
fr.ActuatorStaticDataController = new FiddlerActuatorStaticDataCollectionController(StaticDataCollection);
if (fr.IsRawReplace)
{
if (fr.HttpRawRequest.ParameterizationContent == null)
{
fr.HttpRawRequest.ParameterizationContent = new AutoTest.ParameterizationContent.CaseParameterizationContent(fr.HttpRawRequest.OriginSting);
}
fr.HttpRawRequest.SetActuatorStaticDataCollection(StaticDataCollection);
}
}
}
if (!rawResponseEdit.SetContextMenuStrip(contextMenuStrip_AddFile))
{
MessageBox.Show("RawResponseEdit SetContextMenuStrip fail");
}
}
public MyExecutionDeviceResult ExecutionDeviceRun(ICaseExecutionContent yourExecutionContent, CaseActuator.CaseActionActuator.delegateGetExecutiveData yourExecutiveDelegate, string sender, ActuatorStaticDataCollection yourActuatorStaticDataCollection, int caseId)
{
List <string> errorList = new List <string>();
string tempError = null;
MyExecutionDeviceResult myResult = new MyExecutionDeviceResult();
myResult.staticDataResultCollection = new System.Collections.Specialized.NameValueCollection();
Action <string, CaseActuatorOutPutType, string> ExecutiveDelegate = (innerSender, outType, yourContent) =>
{
if (yourExecutiveDelegate != null)
{
yourExecutiveDelegate(innerSender, outType, yourContent);
}
};
Func <string, bool> DealNowError = (errerData) =>
{
if (errerData != null)
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveError, errerData);
errorList.Add(errerData);
return(true);
}
return(false);
};
Func <string, string, string, bool> DealNowResultError = (errerData, actionType, keyName) =>
{
if (DealNowError(errerData))
{
ExecutiveDelegate(string.Format("[CaseProtocolExecutionForConsole][ExecutionDeviceRun][{0}]", actionType), CaseActuatorOutPutType.ExecutiveError, string.Format("static data {0} error with the key :{1} ", actionType, keyName));
return(true);
}
else
{
return(false);
}
};
if (yourExecutionContent.MyCaseProtocol == CaseProtocol.console)
{
//在调用该函数前保证nowExecutionContent.ErrorMessage为空，且as一定成功
MyConsoleExecutionContent nowExecutionContent = yourExecutionContent as MyConsoleExecutionContent;
myResult.caseProtocol = CaseProtocol.console;
myResult.caseTarget = nowExecutionContent.MyExecutionTarget;
myResult.startTime = DateTime.Now.ToString("HH:mm:ss");
System.Diagnostics.Stopwatch myWatch = new System.Diagnostics.Stopwatch();
myWatch.Start();
#region Show
myResult.backContent = nowExecutionContent.showContent.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
DealNowError(tempError);
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("【ID:{0}】Executive···\r\n【Console】\r\n{1}", caseId, myResult.backContent));
#endregion
#region Add
if (nowExecutionContent.staticDataAddList.Count > 0)
{
foreach (var addInfo in nowExecutionContent.staticDataAddList)
{
switch (CaseRunTimeDataTypeEngine.dictionaryStaticDataTypeClass[addInfo.StaticDataType])
{
//caseStaticDataKey
case CaseStaticDataClass.caseStaticDataKey:
string tempRunTimeDataKey;
if (addInfo.StaticDataType == CaseStaticDataType.caseStaticData_vaule)
{
tempRunTimeDataKey = addInfo.ConfigureData.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
}
else
{
ExecutiveDelegate("[CaseProtocolExecutionForConsole][ExecutionDeviceRun][Add]", CaseActuatorOutPutType.ExecutiveError, string.Format("find nonsupport Protocol"));
break;
}
//如果使用提供的方式进行添加是不会出现错误的（遇到重复会覆盖，只有发现多个同名Key才会返回错误）, 不过getTargetContentData需要处理用户数据可能出现错误。
if (!DealNowResultError(tempError, "Add", addInfo.Name))
{
yourActuatorStaticDataCollection.AddStaticDataKey(addInfo.Name, tempRunTimeDataKey);
ExecutiveDelegate("[CaseProtocolExecutionForConsole][ExecutionDeviceRun][Add]", CaseActuatorOutPutType.ExecutiveInfo, string.Format("static data add success with the key :{0} ", addInfo.Name));
}
break;
//caseStaticDataParameter
case CaseStaticDataClass.caseStaticDataParameter:
IRunTimeStaticData tempRunTimeStaticData;
string tempTypeError;
if (CaseRunTimeDataTypeEngine.dictionaryStaticDataParameterAction[addInfo.StaticDataType](out tempRunTimeStaticData, out tempTypeError, addInfo.ConfigureData.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError)))
{
if (!DealNowResultError(tempError, "Add", addInfo.Name))
{
yourActuatorStaticDataCollection.AddStaticDataParameter(addInfo.Name, tempRunTimeStaticData);
ExecutiveDelegate("[CaseProtocolExecutionForConsole][ExecutionDeviceRun][Add]", CaseActuatorOutPutType.ExecutiveInfo, string.Format("static data add success with the key :{0} ", addInfo.Name));
}
}
else
{
DealNowResultError("[yourActuatorStaticDataCollection][caseStaticDataParameter][GetStaticDataAction] error", "Add", addInfo.Name);
}
break;
//caseStaticDataSource
case CaseStaticDataClass.caseStaticDataSource:
IRunTimeDataSource tempRunTimeDataSource;
if (CaseRunTimeDataTypeEngine.dictionaryStaticDataSourceAction[addInfo.StaticDataType](out tempRunTimeDataSource, out tempTypeError, addInfo.ConfigureData.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError)))
{
if (!DealNowResultError(tempError, "Add", addInfo.Name))
{
yourActuatorStaticDataCollection.AddStaticDataSouce(addInfo.Name, tempRunTimeDataSource);
ExecutiveDelegate("[CaseProtocolExecutionForConsole][ExecutionDeviceRun][Add]", CaseActuatorOutPutType.ExecutiveInfo, string.Format("static data add success with the key :{0} ", addInfo.Name));
}
}
else
{
DealNowResultError("[yourActuatorStaticDataCollection][caseStaticDataSource][GetStaticDataAction] error", "Add", addInfo.Name);
}
break;
default:
DealNowError("[CaseProtocolExecutionForConsole][ExecutionDeviceRun][Add] find nonsupport Protocol");
break;
}
}
}
#endregion
#region Set
if (nowExecutionContent.staticDataSetList.Count > 0)
{
foreach (var addInfo in nowExecutionContent.staticDataSetList)
{
string tempSetVauleStr = addInfo.Value.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
if (!DealNowResultError(tempError, "Set", addInfo.Key))
{
if (yourActuatorStaticDataCollection.SetStaticDataValue(addInfo.Key, tempSetVauleStr))
{
ExecutiveDelegate("[CaseProtocolExecutionForConsole][ExecutionDeviceRun][Set]", CaseActuatorOutPutType.ExecutiveInfo, string.Format("static data set success with the key :{0} ", addInfo.Key));
}
else
{
DealNowResultError("[yourActuatorStaticDataCollection.SetStaticData] error", "Set", addInfo.Key);
}
}
}
}
#endregion
#region Del
if (nowExecutionContent.staticDataDelList.Count > 0)
{
foreach (var delInfo in nowExecutionContent.staticDataDelList)
{
string tempDelVauleStr = delInfo.Value.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
if (!DealNowResultError(tempError, "Del", delInfo.Value.GetTargetContentData()))
{
if (yourActuatorStaticDataCollection.RemoveStaticData(tempDelVauleStr, delInfo.Key))
{
ExecutiveDelegate("[CaseProtocolExecutionForConsole][ExecutionDeviceRun][Del]", CaseActuatorOutPutType.ExecutiveInfo, string.Format("static data del success with the key :{0} ", tempDelVauleStr));
}
else
{
DealNowResultError("[yourActuatorStaticDataCollection.RemoveStaticData] error", "Del", delInfo.Value.GetTargetContentData());
}
}
}
}
#endregion
myWatch.Stop();
myResult.spanTime = myResult.requestTime = myWatch.ElapsedMilliseconds.ToString();
}
else
{
myResult.backContent = "error:your CaseProtocol is not Matching RunTimeActuator";
DealNowError(myResult.backContent);
}
if (errorList.Count > 0)
{
myResult.additionalError = errorList.MyToString("\r\n");
}
return(myResult);
}
//仅用于【caseParameterizationContent】内部
//如果没有任何valid identification，直接返回原始数据，不报错（为实现最大兼容）
/// <summary>
/// get the getTargetContentData in caseParameterizationContent
/// </summary>
/// <param name="yourSourceData">Source Data</param>
/// <param name="yourParameterList">ParameterList</param>
/// <param name="yourStaticDataList">StaticDataList</param>
/// <param name="errorMessage">error Message</param>
/// <returns></returns>
public static string GetCurrentParametersData(string yourSourceData, string splitStr, ActuatorStaticDataCollection yourActuatorStaticDataCollection, NameValueCollection yourDataResultCollection, out string errorMessage)
{
errorMessage = null;
if (yourSourceData.Contains(splitStr))
{
var yourParameterList = yourActuatorStaticDataCollection.RunActuatorStaticDataKeyList;
var yourStaticDataList = yourActuatorStaticDataCollection.RunActuatorStaticDataParameterList;
var yourStaticDataSourceList = yourActuatorStaticDataCollection.RunActuatorStaticDataSouceList;
int tempStart, tempEnd = 0;
string tempKeyVaule = null;
string keyParameter = null;
string keyAdditionData = null;
string tempVaule = null;
while (yourSourceData.Contains(splitStr))
{
tempStart = yourSourceData.IndexOf(splitStr);
tempEnd = yourSourceData.IndexOf(splitStr, tempStart + splitStr.Length);
if (tempEnd == -1)
{
errorMessage = string.Format("the identification not enough in Source[{0}]", yourSourceData);
return(yourSourceData);
}
tempKeyVaule = yourSourceData.Substring(tempStart + splitStr.Length, tempEnd - (tempStart + splitStr.Length));
keyParameter = TryGetParametersAdditionData(tempKeyVaule, out keyAdditionData);
if (keyAdditionData != null)
{
keyAdditionData = GetCurrentParametersData(keyAdditionData, MyConfiguration.ParametersExecuteSplitStr, yourActuatorStaticDataCollection, yourDataResultCollection, out errorMessage);
}
Func <string> DealErrorAdditionData = () =>
{
tempVaule = "[ErrorData]";
return(string.Format("ParametersAdditionData error find in the runTime data with keyParameter:[{0}] keyAdditionData:[{1}]", keyParameter, keyAdditionData));
};
#region RunTimeStaticKey
if (yourParameterList.Keys.Contains(keyParameter))
{
//RunTimeParameter 不含有参数信息，所以不处理keyParameter
tempVaule = yourParameterList[keyParameter].DataCurrent();
yourSourceData = yourSourceData.Replace(splitStr + tempKeyVaule + splitStr, tempVaule);
yourDataResultCollection.MyAdd(tempKeyVaule, tempVaule);
}
#endregion
#region RunTimeStaticParameter
else if (yourStaticDataList.Keys.Contains(keyParameter))
{
if (keyAdditionData == null)
{
tempVaule = yourStaticDataList[keyParameter].DataCurrent();
}
else if (keyAdditionData == "=")
{
tempVaule = yourStaticDataList[keyParameter].DataCurrent();
}
else if (keyAdditionData == "+")
{
tempVaule = yourStaticDataList[keyParameter].DataMoveNext();
}
else if (keyAdditionData.StartsWith("+")) //+10 前移10
{
int tempTimes;
if (int.TryParse(keyAdditionData.Remove(0, 1), out tempTimes))
{
if (tempTimes > 0)
{
for (int i = 0; i < tempTimes; i++)
{
yourStaticDataList[keyParameter].DataMoveNext();
}
tempVaule = yourStaticDataList[keyParameter].DataCurrent();
}
else
{
errorMessage = DealErrorAdditionData();
}
}
else
{
errorMessage = DealErrorAdditionData();
}
}
else
{
errorMessage = DealErrorAdditionData();
}
yourSourceData = yourSourceData.Replace(splitStr + tempKeyVaule + splitStr, tempVaule);
yourDataResultCollection.MyAdd(tempKeyVaule, tempVaule);
}
#endregion
#region RunTimeStaticDataSource
else if (yourStaticDataSourceList.Keys.Contains(keyParameter))
{
if (keyAdditionData == null)
{
tempVaule = yourStaticDataSourceList[tempKeyVaule].DataCurrent();
}
else if (keyAdditionData == "=")
{
tempVaule = yourStaticDataSourceList[keyParameter].DataCurrent();
}
else if (keyAdditionData == "+")
{
tempVaule = yourStaticDataSourceList[keyParameter].DataMoveNext();
}
else if (keyAdditionData.StartsWith("+")) //+10 前移10
{
int tempTimes;
if (int.TryParse(keyAdditionData.Remove(0, 1), out tempTimes))
{
if (tempTimes > 0)
{
for (int i = 0; i < tempTimes; i++)
{
yourStaticDataSourceList[keyParameter].DataMoveNext();
}
tempVaule = yourStaticDataSourceList[keyParameter].DataCurrent();
}
else
{
errorMessage = DealErrorAdditionData();
}
}
else
{
errorMessage = DealErrorAdditionData();
}
}
else
{
tempVaule = yourStaticDataSourceList[keyParameter].GetDataVaule(keyAdditionData);
if (tempVaule == null)
{
errorMessage = DealErrorAdditionData();
}
}
yourSourceData = yourSourceData.Replace(splitStr + tempKeyVaule + splitStr, tempVaule);
yourDataResultCollection.MyAdd(tempKeyVaule, tempVaule);
}
#endregion
else
{
tempVaule = "[ErrorData]";
errorMessage = string.Format("can not find your key [{0}] in StaticDataList", keyParameter);
yourSourceData = yourSourceData.Replace(splitStr + tempKeyVaule + splitStr, tempVaule);
yourDataResultCollection.MyAdd(tempKeyVaule, tempVaule);
}
}
}
return(yourSourceData);
}
public static ParameterHttpResponse GetHttpResponse(string yourResponse, bool isParameter, ActuatorStaticDataCollection yourActuatorStaticDataCollection)
{
ParameterHttpResponse returnPrameterHttpResponse = GetHttpResponse(yourResponse, isParameter);
//returnPrameterHttpResponse.actuatorStaticDataCollection = yourActuatorStaticDataCollection;
returnPrameterHttpResponse.SetActuatorStaticDataCollection(yourActuatorStaticDataCollection);
return(returnPrameterHttpResponse);
}
public ParameterHttpResponse()
{
actuatorStaticDataCollection = null;
}
/// <summary>
/// 获取运算后的值，掉用此法的该版本的重载将会改变涉及到的staticData数据的游标
/// </summary>
/// <param name="yourActuatorStaticDataCollection">可用staticData集合</param>
/// <param name="yourDataResultCollection">返回对所有staticData数据运算后的结果列表</param>
/// <param name="errorMessage">错误消息（如果没有错误则为null）</param>
/// <returns>运算结果</returns>
public string getTargetContentData(ActuatorStaticDataCollection yourActuatorStaticDataCollection, NameValueCollection yourDataResultCollection, out string errorMessage)
{
string myTargetContentData = contentData;
errorMessage = null;
if (hasParameter)
{
myTargetContentData = CaseTool.GetCurrentParametersData(contentData, MyConfiguration.ParametersDataSplitStr, yourActuatorStaticDataCollection, yourDataResultCollection, out errorMessage);
}
if (encodetype != ParameterizationContentEncodingType.encode_default)
{
switch (encodetype)
{
//base64
case ParameterizationContentEncodingType.encode_base64:
myTargetContentData = Convert.ToBase64String(Encoding.UTF8.GetBytes(myTargetContentData));
break;
case ParameterizationContentEncodingType.decode_base64:
try
{
myTargetContentData = Encoding.UTF8.GetString(Convert.FromBase64String(myTargetContentData));
}
catch (Exception ex)
{
myTargetContentData = "ContentEncoding Error:" + ex.Message;
}
break;
//hex 16
case ParameterizationContentEncodingType.encode_hex16:
myTargetContentData = MyCommonHelper.MyEncryption.StringToHexString(myTargetContentData);
break;
case ParameterizationContentEncodingType.decode_hex16:
try
{
byte[] nowBytes = MyCommonHelper.MyEncryption.HexStringToByte(myTargetContentData, MyEncryption.HexaDecimal.hex16, MyEncryption.ShowHexMode.space);
myTargetContentData = Encoding.UTF8.GetString(nowBytes);
}
catch (Exception ex)
{
myTargetContentData = "ContentEncoding Error:" + ex.Message;
}
break;
//hex 2
case ParameterizationContentEncodingType.encode_hex2:
myTargetContentData = MyCommonHelper.MyEncryption.StringToHexString(myTargetContentData, Encoding.UTF8, MyEncryption.HexaDecimal.hex2, MyEncryption.ShowHexMode.space);
break;
case ParameterizationContentEncodingType.decode_hex2:
try
{
byte[] nowBytes = MyCommonHelper.MyEncryption.HexStringToByte(myTargetContentData, MyEncryption.HexaDecimal.hex2, MyEncryption.ShowHexMode.space);
myTargetContentData = Encoding.UTF8.GetString(nowBytes);
}
catch (Exception ex)
{
myTargetContentData = "ContentEncoding Error:" + ex.Message;
}
break;
default:
errorMessage = "[getTargetContentData] unknow or not supported this encodetype";
break;
}
}
return(myTargetContentData);
}
public MyExecutionDeviceResult ExecutionDeviceRun(ICaseExecutionContent yourExecutionContent, CaseActionActuator.delegateGetExecutiveData yourExecutiveDelegate, string sender, ActuatorStaticDataCollection yourActuatorStaticDataCollection, int caseId)
{
List <string> errorList = new List <string>();
string tempError = null;
MyExecutionDeviceResult myResult = new MyExecutionDeviceResult();
myResult.staticDataResultCollection = new System.Collections.Specialized.NameValueCollection();
//向UI推送执行过程信息
Action <string, CaseActuatorOutPutType, string> ExecutiveDelegate = (innerSender, outType, yourContent) =>
{
if (yourExecutiveDelegate != null)
{
yourExecutiveDelegate(innerSender, outType, yourContent);
}
};
//处理执行错误（执行器无法执行的错误）
Action <string> DealExecutiveError = (errerData) =>
{
if (errerData != null)
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveError, errerData);
errorList.Add(errerData);
}
};
if (yourExecutionContent.MyCaseProtocol == CaseProtocol.mysql)
{
//在调用该函数前保证nowExecutionContent.ErrorMessage为空，且as一定成功
MyMySqlExecutionContent nowExecutionContent = yourExecutionContent as MyMySqlExecutionContent;
myResult.caseProtocol = CaseProtocol.mysql;
myResult.caseTarget = nowExecutionContent.MyExecutionTarget;
myResult.startTime = DateTime.Now.ToString("HH:mm:ss");
StringBuilder tempCaseOutContent = new StringBuilder();
System.Diagnostics.Stopwatch myWatch = new System.Diagnostics.Stopwatch();
myWatch.Start();
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("【ID:{0}】[mysql]Executive···", caseId));
string nowSqlCmd = nowExecutionContent.sqlContent.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
if (tempError != null)
{
DealExecutiveError(string.Format("this case get static data errer with [{0}]", nowExecutionContent.sqlContent.GetTargetContentData()));
tempCaseOutContent.AppendLine("error with static data");
}
else
{
if (nowExecutionContent.isPosition)
{
string sqlResult = mySqlDrive.ExecuteQuery(nowSqlCmd, nowExecutionContent.rowIndex, nowExecutionContent.columnIndex);
if (sqlResult == null)
{
tempCaseOutContent.AppendLine(string.Format("error in [ExecuteQuery] :{0}", mySqlDrive.NowError));
DealExecutiveError(mySqlDrive.NowError);
}
else
{
tempCaseOutContent.AppendLine(sqlResult);
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, sqlResult);
}
}
else
{
System.Data.DataTable sqlResult = mySqlDrive.ExecuteQuery(nowSqlCmd);
if (sqlResult == null)
{
tempCaseOutContent.AppendLine(string.Format("error in [ExecuteQuery] :{0}", mySqlDrive.NowError));
DealExecutiveError(mySqlDrive.NowError);
}
else
{
string json = Newtonsoft.Json.JsonConvert.SerializeObject(sqlResult, Newtonsoft.Json.Formatting.Indented);
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, json);
tempCaseOutContent.AppendLine(json);
}
}
}
myWatch.Stop();
myResult.spanTime = myResult.requestTime = myWatch.ElapsedMilliseconds.ToString();
myResult.backContent = tempCaseOutContent.ToString();
}
else
{
myResult.backContent = "error:your CaseProtocol is not Matching RunTimeActuator";
DealExecutiveError(myResult.backContent);
}
if (errorList.Count > 0)
{
myResult.additionalError = errorList.MyToString("\r\n");
}
return(myResult);
}
public MyExecutionDeviceResult ExecutionDeviceRun(ICaseExecutionContent yourExecutionContent, CaseActionActuator.delegateGetExecutiveData yourExecutiveDelegate, string sender, ActuatorStaticDataCollection yourActuatorStaticDataCollection, int caseId)
{
List <string> errorList = new List <string>();
string tempError = null;
MyExecutionDeviceResult myResult = new MyExecutionDeviceResult();
myResult.staticDataResultCollection = new System.Collections.Specialized.NameValueCollection();
//向UI推送执行过程信息
Action <string, CaseActuatorOutPutType, string> ExecutiveDelegate = (innerSender, outType, yourContent) =>
{
if (yourExecutiveDelegate != null)
{
yourExecutiveDelegate(innerSender, outType, yourContent);
}
};
//处理执行错误（执行器无法执行的错误）
Action <string> DealExecutiveError = (errerData) =>
{
if (errerData != null)
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveError, errerData);
errorList.Add(errerData);
}
};
if (yourExecutionContent.MyCaseProtocol == CaseProtocol.com)
{
//在调用该函数前保证nowExecutionContent.ErrorMessage为空，且as一定成功
MyComExecutionContent nowExecutionContent = yourExecutionContent as MyComExecutionContent;
myResult.caseProtocol = CaseProtocol.com;
myResult.caseTarget = nowExecutionContent.MyExecutionTarget;
myResult.startTime = DateTime.Now.ToString("HH:mm:ss");
StringBuilder tempCaseOutContent = new StringBuilder();
System.Diagnostics.Stopwatch myWatch = new System.Diagnostics.Stopwatch();
myWatch.Start();
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("【ID:{0}】[com]Executive···", caseId));
#region Send
if (nowExecutionContent.isSend)
{
string nowComData = nowExecutionContent.comContentToSend.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
if (tempError != null)
{
DealExecutiveError(string.Format("this case get static data errer with [{0}]", nowExecutionContent.comContentToSend.GetTargetContentData()));
tempCaseOutContent.AppendLine("error with static data");
}
else
{
byte[] nowSendBytes;
if (nowExecutionContent.comSendEncoding == null)
{
try
{
nowSendBytes = MyBytes.HexStringToByte(nowComData, HexaDecimal.hex16, ShowHexMode.space);
}
catch
{
nowSendBytes = null;
}
}
else
{
try
{
nowSendBytes = nowExecutionContent.comSendEncoding.GetBytes(nowComData);
}
catch
{
nowSendBytes = null;
}
}
if (nowSendBytes == null)
{
DealExecutiveError(string.Format("can not change data to bytes with [{0}]", nowExecutionContent.comContentToSend.GetTargetContentData()));
tempCaseOutContent.AppendLine("error with com data");
}
else
{
if (mySerialPort.Send(nowSendBytes))
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, "send sucess");
tempCaseOutContent.AppendLine("send sucess");
}
else
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveError, mySerialPort.ErroerMessage);
tempCaseOutContent.AppendLine(mySerialPort.ErroerMessage);
}
}
}
}
#endregion
#region receive
if (nowExecutionContent.isReceive)
{
if (nowExecutionContent.comSleepTime > 0)
{
System.Threading.Thread.Sleep(nowExecutionContent.comSleepTime);
}
byte[] recweiveBytes = mySerialPort.ReadAllBytes();
if (recweiveBytes != null)
{
string receiveStr;
if (nowExecutionContent.comReceiveEncoding == null)
{
receiveStr = MyBytes.ByteToHexString(recweiveBytes, HexaDecimal.hex16, ShowHexMode.space);
}
else
{
try
{
receiveStr = nowExecutionContent.comReceiveEncoding.GetString(recweiveBytes);
}
catch
{
receiveStr = null;
}
}
if (receiveStr != null)
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, receiveStr);
tempCaseOutContent.AppendLine(receiveStr);
}
else
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveError, string.Format("can not Encoding your data with {0}", MyBytes.ByteToHexString(recweiveBytes, HexaDecimal.hex16, ShowHexMode.space)));
tempCaseOutContent.AppendLine("[error]receive data error can not encoding receive data");
}
}
}
#endregion
myWatch.Stop();
myResult.spanTime = myResult.requestTime = myWatch.ElapsedMilliseconds.ToString();
myResult.backContent = tempCaseOutContent.ToString();
}
else
{
myResult.backContent = "error:your CaseProtocol is not Matching RunTimeActuator";
DealExecutiveError(myResult.backContent);
}
if (errorList.Count > 0)
{
myResult.additionalError = errorList.MyToString("\r\n");
}
return(myResult);
}
public MyExecutionDeviceResult ExecutionDeviceRun(ICaseExecutionContent yourExecutionContent, CaseActionActuator.delegateGetExecutiveData yourExecutiveDelegate, string sender, ActuatorStaticDataCollection yourActuatorStaticDataCollection, int caseId)
{
MyExecutionDeviceResult myResult = new MyExecutionDeviceResult();
myResult.staticDataResultCollection = new System.Collections.Specialized.NameValueCollection();
if (yourExecutionContent.MyCaseProtocol == CaseProtocol.http)
{
//在调用该函数前保证nowExecutionContent.ErrorMessage为空，且as一定成功
MyBasicHttpExecutionContent nowExecutionContent = yourExecutionContent as MyBasicHttpExecutionContent;
myResult.caseProtocol = CaseProtocol.http;
myResult.caseTarget = nowExecutionContent.MyExecutionTarget;
string tempError;
string httpUri;
string httpBody = null;
List <KeyValuePair <string, string> > httpHeads = null;
httpUri = nowExecutionContent.httpUri.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
if (httpUri.StartsWith("@"))
{
httpUri = myExecutionDeviceInfo.default_url + httpUri.Remove(0, 1);
}
if (nowExecutionContent.httpBody.IsFilled())
{
httpBody = nowExecutionContent.httpBody.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
}
if (nowExecutionContent.httpHeads.Count > 0)
{
httpHeads = new List <KeyValuePair <string, string> >();
foreach (var tempHead in nowExecutionContent.httpHeads)
{
httpHeads.Add(new KeyValuePair <string, string>(tempHead.Key, tempHead.Value.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError)));
}
}
//report Executive Data
if (yourExecutiveDelegate != null)
{
if (httpBody != null)
{
yourExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("【ID:{0}】[http]Executive···\r\n{1}\r\n{2}", caseId, httpUri, httpBody));
}
else
{
yourExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("【ID:{0}】[http]Executive···\r\n{1}", caseId, httpUri));
}
}
//Start Http
if (nowExecutionContent.myMultipartList.Count > 0)
{
List <MyCommonHelper.NetHelper.MyWebTool.HttpMultipartDate> myMultiparts = new List <MyCommonHelper.NetHelper.MyWebTool.HttpMultipartDate>();
foreach (HttpMultipart tempPt in nowExecutionContent.myMultipartList)
{
if (tempPt.IsFilled())
{
myMultiparts.Add(new MyCommonHelper.NetHelper.MyWebTool.HttpMultipartDate(tempPt.name, tempPt.fileName, null, tempPt.isFile, tempPt.fileData));
}
}
httpClient.HttpPostData(httpUri, httpHeads, httpBody, myMultiparts, null, MyConfiguration.PostFileTimeOut, null, myResult);
}
else if (nowExecutionContent.myHttpAisleConfig.httpDataDown.IsFilled())
{
httpClient.SendData(httpUri, httpBody, nowExecutionContent.httpMethod, httpHeads, myResult, CaseTool.GetFullPath(nowExecutionContent.myHttpAisleConfig.httpDataDown.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError), MyConfiguration.CaseFilePath));
}
else
{
httpClient.SendData(httpUri, httpBody, nowExecutionContent.httpMethod, httpHeads, myResult);
}
if (tempError != null)
{
myResult.additionalError = ("error:" + tempError);
}
}
else
{
myResult.additionalError = ("error:your CaseProtocol is not Matching RunTimeActuator");
myResult.backContent = "error:your CaseProtocol is not Matching RunTimeActuator";
}
return(myResult);
}
public void SetActuatorStaticDataCollection(ActuatorStaticDataCollection yourStaticDataCollection)
{
actuatorStaticDataCollection = yourStaticDataCollection;
}
public MyExecutionDeviceResult ExecutionDeviceRun(ICaseExecutionContent yourExecutionContent, CaseActionActuator.delegateGetExecutiveData yourExecutiveDelegate, string sender, ActuatorStaticDataCollection yourActuatorStaticDataCollection, int caseId)
{
List <string> errorList = new List <string>();
string tempError = null;
MyExecutionDeviceResult myResult = new MyExecutionDeviceResult();
myResult.staticDataResultCollection = new System.Collections.Specialized.NameValueCollection();
Action <string, CaseActuatorOutPutType, string> ExecutiveDelegate = (innerSender, outType, yourContent) =>
{
if (yourExecutiveDelegate != null)
{
yourExecutiveDelegate(innerSender, outType, yourContent);
}
};
Action <string> DealExecutiveError = (errerData) =>
{
if (errerData != null)
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveError, errerData);
errorList.Add(errerData);
}
};
if (yourExecutionContent.MyCaseProtocol == CaseProtocol.activeMQ)
{
//在调用该函数前保证nowExecutionContent.ErrorMessage为空，且as一定成功
MyActiveMQExecutionContent nowExecutionContent = yourExecutionContent as MyActiveMQExecutionContent;
myResult.caseProtocol = CaseProtocol.activeMQ;
myResult.caseTarget = nowExecutionContent.MyExecutionTarget;
myResult.startTime = DateTime.Now.ToString("HH:mm:ss");
StringBuilder tempCaseOutContent = new StringBuilder();
System.Diagnostics.Stopwatch myWatch = new System.Diagnostics.Stopwatch();
myWatch.Start();
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("【ID:{0}】[activeMQ]Executive···", caseId));
#region Subscribe
foreach (var tempConsumer in nowExecutionContent.consumerSubscribeList)
{
if (tempConsumer.ConsumerType == "queue" || tempConsumer.ConsumerType == "topic")
{
if (activeMQ.SubscribeConsumer(tempConsumer.ConsumerName, tempConsumer.ConsumerType == "queue", tempConsumer.ConsumerTopicDurable))
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("{0}://{1} subscribe success", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
}
else
{
DealExecutiveError(string.Format("{0}://{1} subscribe fail", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
}
}
else
{
DealExecutiveError(string.Format("{0}://{1} subscribe fail [not support this consumer type]", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
}
}
#endregion
#region UnSubscribe
foreach (var tempConsumer in nowExecutionContent.unConsumerSubscribeList)
{
if (tempConsumer.ConsumerType == "queue" || tempConsumer.ConsumerType == "topic")
{
if (activeMQ.UnSubscribeConsumer(string.Format("{0}://{1}", tempConsumer.ConsumerType, tempConsumer.ConsumerName)) > 0)
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("{0}://{1} unsubscribe success", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
}
else
{
DealExecutiveError(string.Format("{0}://{1} unsubscribe fail", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
}
}
else
{
DealExecutiveError(string.Format("{0}://{1} unsubscribe fail [not support this consumer type]", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
}
}
#endregion
#region Send
foreach (var tempOneSender in nowExecutionContent.producerDataSendList)
{
if (tempOneSender.Key.ProducerType == "queue" || tempOneSender.Key.ProducerType == "topic")
{
string tempMessageSend = tempOneSender.Value.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
if (tempError != null)
{
DealExecutiveError(string.Format("this case get static data errer with [{0}]", tempOneSender.Value.GetTargetContentData()));
tempCaseOutContent.AppendLine(string.Format("{0}://{1} send message fail [get static data errer]", tempOneSender.Key.ProducerType, tempOneSender.Key.ProducerName));
}
else
{
MessageType tempMessageType;
if (Enum.TryParse <MessageType>(tempOneSender.Key.MessageType, out tempMessageType))
{
if (activeMQ.PublishMessage(tempOneSender.Key.ProducerName, tempMessageSend, tempOneSender.Key.ProducerType == "topic", tempMessageType))
{
string tempReportStr = string.Format("{0}://{1} send message success", tempOneSender.Key.ProducerType, tempOneSender.Key.ProducerName);
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, tempReportStr);
tempCaseOutContent.AppendLine(tempReportStr);
}
else
{
string tempReportStr = string.Format("{0}://{1} send message fail [{2}]", tempOneSender.Key.ProducerType, tempOneSender.Key.ProducerName, activeMQ.NowErrorMes);
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, tempReportStr);
tempCaseOutContent.AppendLine(tempReportStr);
}
}
else
{
DealExecutiveError(string.Format("get MessageType errer with [{0}]", tempOneSender.Key.MessageType));
tempCaseOutContent.AppendLine(string.Format("{0}://{1} send message fail [get MessageType errer]", tempOneSender.Key.ProducerType, tempOneSender.Key.ProducerName));
}
}
}
else
{
tempCaseOutContent.Append(string.Format("{0}://{1} send message fail [not support this producer type]", tempOneSender.Key.ProducerType, tempOneSender.Key.ProducerName));
}
}
#endregion
#region Receive
if (nowExecutionContent.consumerMessageReceiveList.Count > 0)
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, "Receive your activeMQ messages");
}
foreach (var tempConsumer in nowExecutionContent.consumerMessageReceiveList)
{
if (tempConsumer.ConsumerName != null)
{
if (tempConsumer.ConsumerType == "queue" || tempConsumer.ConsumerType == "topic")
{
List <KeyValuePair <string, string> > oneMessageReceive = activeMQ.ReadConsumerMessage(string.Format("{0}://{1}", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
foreach (KeyValuePair <string, string> tempMessage in oneMessageReceive)
{
string tempNowReceviceData = string.Format("{0} Receive {1}", tempMessage.Key, tempMessage.Value);
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, tempNowReceviceData);
tempCaseOutContent.AppendLine(tempNowReceviceData);
}
}
else
{
DealExecutiveError(string.Format("{0}://{1} receive fail [not support this consumer type]", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
tempCaseOutContent.AppendLine(string.Format("{0}://{1} receive fail ", tempConsumer.ConsumerType, tempConsumer.ConsumerName));
}
}
else
{
List <KeyValuePair <string, string> > oneMessageReceive = activeMQ.ReadConsumerMessage();
foreach (KeyValuePair <string, string> tempMessage in oneMessageReceive)
{
string tempNowReceviceData = string.Format("{0} Receive {1}", tempMessage.Key, tempMessage.Value);
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, tempNowReceviceData);
tempCaseOutContent.AppendLine(tempNowReceviceData);
}
}
}
#endregion
myWatch.Stop();
myResult.spanTime = myResult.requestTime = myWatch.ElapsedMilliseconds.ToString();
myResult.backContent = tempCaseOutContent.ToString();
}
else
{
myResult.backContent = "error:your CaseProtocol is not Matching RunTimeActuator";
DealExecutiveError(myResult.backContent);
}
if (errorList.Count > 0)
{
myResult.additionalError = errorList.MyToString("\r\n");
}
return(myResult);
}
public async Task UploadRulesAsync <T1, T2>(List <T1> requestRules, List <T2> responseRules, ActuatorStaticDataCollection staticDataCollection = null) where T1 : IFiddlerHttpTamper where T2 : IFiddlerHttpTamper
{
MultipartFormDataContent multipartFormData = new MultipartFormDataContent();
if (staticDataCollection != null)
{
multipartFormData.Add(new StringContent(MyJsonHelper.JsonDataContractJsonSerializer.ObjectToJsonStr(staticDataCollection)), "staticData");
}
if (requestRules != null)
{
foreach (var request in requestRules)
{
multipartFormData.Add(new StringContent(MyJsonHelper.JsonDataContractJsonSerializer.ObjectToJsonStr(request)), "requestRule");
}
}
if (responseRules != null)
{
foreach (var response in responseRules)
{
multipartFormData.Add(new StringContent(MyJsonHelper.JsonDataContractJsonSerializer.ObjectToJsonStr(response)), "responseRule");
}
}
try
{
await httpClient.PostAsync(string.Format(@"{0}freehttp/RuleDetails?ruleversion={1}&{2}", ConfigurationData.BaseUrl, UserComputerInfo.GetRuleVersion(), WebService.UserComputerInfo.GetFreeHttpUser()), multipartFormData);
}
catch (Exception ex)
{
await RemoteLogService.ReportLogAsync(ex.ToString(), RemoteLogService.RemoteLogOperation.RuleUpload, RemoteLogService.RemoteLogType.Error);
}
finally
{
}
}
public MyExecutionDeviceResult ExecutionDeviceRun(ICaseExecutionContent yourExecutionContent, CaseActionActuator.delegateGetExecutiveData yourExecutiveDelegate, string sender, ActuatorStaticDataCollection yourActuatorStaticDataCollection, int caseId)
{
List <string> errorList = new List <string>();
string tempError = null;
MyExecutionDeviceResult myResult = new MyExecutionDeviceResult();
myResult.staticDataResultCollection = new System.Collections.Specialized.NameValueCollection();
//向UI推送执行过程信息
Action <string, CaseActuatorOutPutType, string> ExecutiveDelegate = (innerSender, outType, yourContent) =>
{
if (yourExecutiveDelegate != null)
{
yourExecutiveDelegate(innerSender, outType, yourContent);
}
};
//处理执行错误（执行器无法执行的错误）
Action <string> DealExecutiveError = (errerData) =>
{
if (errerData != null)
{
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveError, errerData);
errorList.Add(errerData);
}
};
if (yourExecutionContent.MyCaseProtocol == CaseProtocol.ssh)
{
//在调用该函数前保证nowExecutionContent.ErrorMessage为空，且as一定成功
MySshExecutionContent nowExecutionContent = yourExecutionContent as MySshExecutionContent;
myResult.caseProtocol = CaseProtocol.ssh;
myResult.caseTarget = nowExecutionContent.MyExecutionTarget;
myResult.startTime = DateTime.Now.ToString("HH:mm:ss");
StringBuilder tempCaseOutContent = new StringBuilder();
System.Diagnostics.Stopwatch myWatch = new System.Diagnostics.Stopwatch();
myWatch.Start();
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("【ID:{0}】[ssh]Executive···", caseId));
string nowSshCmd = nowExecutionContent.sshContent.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError);
if (tempError != null)
{
DealExecutiveError(string.Format("this case get static data errer with [{0}]", nowExecutionContent.sshContent.GetTargetContentData()));
tempCaseOutContent.AppendLine("error with static data");
}
else
{
try
{
sshShell.WriteLine(nowSshCmd);
string tempResult = sshShell.Expect();
ExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, tempResult);
tempCaseOutContent.AppendLine(tempResult);
}
catch (Exception ex)
{
DealExecutiveError(ex.Message);
tempCaseOutContent.AppendLine(ex.Message);
}
}
myWatch.Stop();
myResult.spanTime = myResult.requestTime = myWatch.ElapsedMilliseconds.ToString();
myResult.backContent = tempCaseOutContent.ToString();
}
else
{
myResult.backContent = "error:your CaseProtocol is not Matching RunTimeActuator";
DealExecutiveError(myResult.backContent);
}
if (errorList.Count > 0)
{
myResult.additionalError = errorList.MyToString("\r\n");
}
return(myResult);
}
public ParameterHttpRequest()
{
actuatorStaticDataCollection = null;
}
public static async Task <string> UploadRulesAsync <T1, T2>(List <T1> requestRules, List <T2> responseRules, ActuatorStaticDataCollection staticDataCollection = null, FiddlerRuleGroup ruleGroup = null, string executeUrl = null) where T1 : IFiddlerHttpTamper where T2 : IFiddlerHttpTamper
{
MultipartFormDataContent multipartFormData = new MultipartFormDataContent();
if (staticDataCollection != null)
{
multipartFormData.Add(new StringContent(MyJsonHelper.JsonDataContractJsonSerializer.ObjectToJsonStr(staticDataCollection)), "staticData");
}
if (ruleGroup != null)
{
multipartFormData.Add(new StringContent(MyJsonHelper.JsonDataContractJsonSerializer.ObjectToJsonStr(ruleGroup)), "groupData");
}
if (requestRules != null)
{
foreach (var request in requestRules)
{
multipartFormData.Add(new StringContent(MyJsonHelper.JsonDataContractJsonSerializer.ObjectToJsonStr(request)), "requestRule");
}
}
if (responseRules != null)
{
foreach (var response in responseRules)
{
multipartFormData.Add(new StringContent(MyJsonHelper.JsonDataContractJsonSerializer.ObjectToJsonStr(response)), "responseRule");
}
}
try
{
HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(string.Format(executeUrl ?? _uploadRuleUrl, ConfigurationData.BaseUrl, UserComputerInfo.GetRuleVersion(), WebService.UserComputerInfo.GetFreeHttpUser()), multipartFormData);
if (httpResponseMessage.IsSuccessStatusCode)
{
return(await httpResponseMessage.Content.ReadAsStringAsync());
}
}
catch (Exception ex)
{
await RemoteLogService.ReportLogAsync(ex.ToString(), RemoteLogService.RemoteLogOperation.RuleUpload, RemoteLogService.RemoteLogType.Error);
}
finally
{
}
return(null);
}
public static ParameterHttpRequest GetHttpRequest(string yourRequest, bool isParameter, ActuatorStaticDataCollection yourActuatorStaticDataCollection)
{
ParameterHttpRequest returnPrameterHttpRequest = GetHttpRequest(yourRequest, isParameter);
//returnPrameterHttpRequest.actuatorStaticDataCollection = yourActuatorStaticDataCollection;
returnPrameterHttpRequest.SetActuatorStaticDataCollection(yourActuatorStaticDataCollection);
return(returnPrameterHttpRequest);
}
public FiddlerActuatorStaticDataCollectionController(ActuatorStaticDataCollection yourStaticDataCollection)
{
actuatorStaticDataCollection = yourStaticDataCollection;
}
public void SetUseParameterInfo(bool isUseParameter, ActuatorStaticDataCollection yourStaticDataCollection)
{
ParameterizationContent.hasParameter = isUseParameter;
actuatorStaticDataCollection = yourStaticDataCollection;
}
public MyExecutionDeviceResult ExecutionDeviceRun(ICaseExecutionContent yourExecutionContent, CaseActionActuator.delegateGetExecutiveData yourExecutiveDelegate, string sender, ActuatorStaticDataCollection yourActuatorStaticDataCollection, int caseId)
{
MyExecutionDeviceResult myResult = new MyExecutionDeviceResult();
myResult.staticDataResultCollection = new System.Collections.Specialized.NameValueCollection();//默认该值为null，不会输出参数数据结果（如果不需要输出可以保持该字段为null）
if (yourExecutionContent.MyCaseProtocol == CaseProtocol.vanelife_http)
{
//在调用该函数前保证nowExecutionContent.ErrorMessage为空，且as一定成功
MyVaneHttpExecutionContent nowExecutionContent = yourExecutionContent as MyVaneHttpExecutionContent;
myResult.caseProtocol = CaseProtocol.vanelife_http;
myResult.caseTarget = nowExecutionContent.MyExecutionTarget;
string tempError;
string tempUrlAddress;
string vanelifeData = CreatVanelifeSendData(nowExecutionContent.caseExecutionContent.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError));
if (nowExecutionContent.myHttpAisleConfig.httpAddress.IsFilled())
{
tempUrlAddress = nowExecutionContent.myHttpAisleConfig.httpAddress.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError) + nowExecutionContent.httpTarget;
}
else
{
tempUrlAddress = myExecutionDeviceInfo.default_url + nowExecutionContent.httpTarget;
}
//report Executive Data
if (yourExecutiveDelegate != null)
{
yourExecutiveDelegate(sender, CaseActuatorOutPutType.ExecutiveInfo, string.Format("【ID:{0}】[vanelife_http]Executive···\r\n{1}\r\n{2}", caseId, tempUrlAddress, vanelifeData));
}
//Start Http
if (nowExecutionContent.myHttpAisleConfig.httpDataDown.IsFilled())
{
httpClient.SendData(tempUrlAddress, vanelifeData, nowExecutionContent.httpMethod, myResult, CaseTool.GetFullPath(nowExecutionContent.myHttpAisleConfig.httpDataDown.GetTargetContentData(yourActuatorStaticDataCollection, myResult.staticDataResultCollection, out tempError), MyConfiguration.CaseFilePath));
}
else
{
if (nowExecutionContent.myHttpMultipart.IsFilled())
{
//由于vanelife协议要求在Multipart把业务数据全部放在了url中
httpClient.HttpPostData(tempUrlAddress + "?" + vanelifeData, 30000, nowExecutionContent.myHttpMultipart.name, nowExecutionContent.myHttpMultipart.fileName, nowExecutionContent.myHttpMultipart.isFile, nowExecutionContent.myHttpMultipart.fileData, null, myResult);
}
else
{
httpClient.SendData(tempUrlAddress, vanelifeData, nowExecutionContent.httpMethod, myResult);
}
}
if (tempError != null)
{
myResult.additionalError = ("error:" + tempError);
}
}
else
{
myResult.backContent = "error:your CaseProtocol is not Matching RunTimeActuator";
myResult.additionalError = ("error:your CaseProtocol is not Matching RunTimeActuator");
}
return(myResult);
}
