/// <summary>
/// Исключает Default словари(Predicates, Functions и т.д.) не предназначенные для Экспорта
/// </summary>
/// <param name="vocab"></param>
/// <returns></returns>
private static bool IsIgnorVocab(VocabularyInfo vocab)
{
var appSettings = ConfigurationManager.AppSettings;
if (appSettings.Count == 0)
{
Error?.Invoke("appSetings пуст");
}
else
{
var settingsStr = appSettings["ignorVocab"];
var settings = settingsStr.Split(';');
foreach (var setting in settings)
{
var nameAndVersion = setting.Split(',');
var name = nameAndVersion[0];
var version = nameAndVersion[1].Split('.');
var majorV = int.Parse(version[0]);
var minorV = int.Parse(version[1]);
if ((name == vocab.Name) & (majorV == vocab.MajorRevision) & (minorV == vocab.MinorRevision))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// 搜尋單字
/// </summary>
/// <param name="word">單字</param>
/// <param name="baseUrl">Server網址</param>
/// <param name="baseReturn">回傳結果</param>
/// <param name="strategy">策略</param>
/// <returns></returns>
public VocabularyInfo SearchVocabulary(string word, out BaseInfo baseReturn, SearchWordStrategy strategy)
{
baseReturn = new BaseInfo();
VocabularyInfo searchRE = null;
try
{
searchRE = strategy.Search(word);
}
catch (Exception)
{
baseReturn.returnMsgNo = -2;
baseReturn.returnMsg = "查詢發生例外錯誤";
}
if (searchRE == null)
{
baseReturn.returnMsgNo = -1;
baseReturn.returnMsg = "沒有找到相關的單字";
}
else
{
baseReturn.returnMsgNo = 1;
baseReturn.returnMsg = "搜尋成功!";
}
return(searchRE);
}
private static void ProcessVocabularies(
DeployRulesCommandLine cl, Microsoft.BizTalk.RuleEngineExtensions.RuleSetDeploymentDriver dd)
{
RuleStore ruleStore = dd.GetRuleStore();
VocabularyInfoCollection vInfo = ruleStore.GetVocabularies(cl.vocabularyName, RuleStore.Filter.All);
Version version = ParseVersion(cl.ruleSetVersion);
VocabularyInfo matchingVocabularyInfo = null;
foreach (VocabularyInfo currentRsi in vInfo)
{
if (currentRsi.MajorRevision == version.Major &&
currentRsi.MinorRevision == version.Minor)
{
matchingVocabularyInfo = currentRsi;
break;
}
}
if (matchingVocabularyInfo == null)
{
Console.WriteLine(
"No published vocabulary with name '" + cl.vocabularyName + "' and version '" + cl.ruleSetVersion + "'.");
}
else if (cl.unpublish)
{
Console.WriteLine("Unpublishing vocabulary '{0}' version {1}.{2}...", cl.vocabularyName, version.Major, version.Minor);
ruleStore.Remove(matchingVocabularyInfo);
}
}
public void Show(VocabularyInfo file)
{
this.file = file;
DataGrid.ItemsSource = new ObservableCollection <WordInfo>(file.Vocabulary.Words);
TotalAmountLabel.Content = file.Vocabulary.WordCount;
FilenameLabel.Content = file.Filename.Split('\\').Last();
}
public IHttpActionResult AddToFavorite(VocabularyInfo model)
{
// 取得用戶資料
string guestID = UserInformationHelper.GetUserGuestID();
BaseInfo baseReturn;
_vocabularyService.SaveVocabulary(guestID, model, out baseReturn);
return(Ok(baseReturn));
}
/// <summary>
/// 儲存單字
/// </summary>
public void SaveVocabulary(string guestID, VocabularyInfo model, out BaseInfo saveReturn)
{
saveReturn = new BaseInfo();
var vocabularyModel = _mapper.Map <VocabularyInfo, VocabularyDictionarys>(model);
try
{
// 先看用戶是否儲存過了
// 用戶單字collection
var vocabularyCollect = _unitOfWork.UsersRepository
.Get(filter: u => u.GuestID == guestID, includeProperties: "VocabularyDictionarys")
.FirstOrDefault()
.VocabularyDictionarys;
if (vocabularyCollect.Any(v => v.Vocabulary.ToLower().Trim() == model.Word.ToLower().Trim())) // 檢查是否已儲存過
{
saveReturn.returnMsgNo = -2;
saveReturn.returnMsg = "單字已儲存過。";
return;
}
//再看字典庫裡有沒有儲存過此單字
var vocabularyOld = _unitOfWork.VocabularyDictionarysRepository
.Get(filter: v => v.Vocabulary == model.Word).FirstOrDefault();
if (vocabularyOld == null) //沒有則首次加入
{
_unitOfWork.VocabularyDictionarysRepository.Insert(vocabularyModel);
}
else
{
vocabularyModel = vocabularyOld; // 取代為字典庫內的
}
// 用戶增加儲存的單字
vocabularyCollect.Add(vocabularyModel);
_unitOfWork.SaveChanges();
}
catch (Exception ex)
{
saveReturn.returnMsgNo = -1;
saveReturn.returnMsg = "儲存單字時發生例外錯誤。";
return;
}
saveReturn.returnMsgNo = 1;
saveReturn.returnMsg = "單字儲存成功!";
// Success End
}
/// <summary>
/// подключается к БД и возвращает все vocab(включая default vocab) из БД
/// </summary>
/// <param name="serverName"></param>
/// <param name="dbName"></param>
/// <returns></returns>
public static VocabularyInfo[] GetVocabularyInfoSet(string serverName, string dbName)
{
RuleStore vocabStore = ((IRuleSetDeploymentDriver)Microsoft.RuleEngine.RemoteUpdateService.RemoteUpdateService.LocateObject(Configuration.DeploymentDriverClass, Configuration.DeploymentDriverDll, new ArrayList()
{
serverName,
dbName
}.ToArray())).GetRuleStore();
var vocabularyInfoCollection = vocabStore.GetVocabularies(RuleStore.Filter.All);
var vocabularySet = new VocabularyInfo[vocabularyInfoCollection.Count];
vocabularyInfoCollection.CopyTo(vocabularySet, 0);
return(vocabularySet);
}
public static int DeleteVocabulary(string name, int majorVersion, int minorVersion, out string message)
{
int result = 0;
try
{
VocabularyInfo vInfo = new VocabularyInfo(name, majorVersion, minorVersion);
Microsoft.BizTalk.RuleEngineExtensions.RuleSetDeploymentDriver rdd = new Microsoft.BizTalk.RuleEngineExtensions.RuleSetDeploymentDriver();
SqlRuleStore ruleStore = (SqlRuleStore)rdd.GetRuleStore();
ruleStore.Remove(vInfo);
message = "Successfully Deleted";
}
catch (Exception exe)
{
message = exe.Message;
return(-1);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="vocabulary"></param>
/// <param name="outputFolder"></param>
/// <returns></returns>
public string ExportVocabularyToFile(RuleArtifact vocabulary, string outputFolder)
{
string fileName = null;
TraceManager.SmartTrace.TraceIn();
try
{
RuleSetDeploymentDriver rsdd = new RuleSetDeploymentDriver(this.server, this.database);
VocabularyInfo vi = new VocabularyInfo(vocabulary.Name, vocabulary.MajorVersion, vocabulary.MinorVersion);
fileName = Path.Combine(outputFolder, vocabulary.XmlFileName);
rsdd.ExportVocabularyToFileRuleStore(vi, fileName);
}
catch (Exception ex)
{
TraceManager.SmartTrace.TraceError(ex);
TraceManager.SmartTrace.TraceError("FileName will be set to NULL");
}
TraceManager.SmartTrace.TraceOut();
return(fileName);
}
/// <summary>
/// 根据词汇状态查询
/// </summary>
/// <param name="state">状态(0：禁用,1：启用)</param>
/// <returns></returns>
public List <VocabularyInfo> GetVocabularyListByState(int state)
{
string sql = "SELECT [Id],[VocabularyName],[State],[Operator],[OperatingTime] FROM [dbo].[Vocabulary] WHERE [State]=" + state;
var list = new List <VocabularyInfo>();
using (var rdr = SqlHelper.ExecuteReader(GlobalConfig.ERP_DB_NAME, true, sql))
{
while (rdr.Read())
{
var vocabularyInfo = new VocabularyInfo
{
Id = rdr["Id"] == DBNull.Value ? Guid.Empty : new Guid(rdr["Id"].ToString()),
VocabularyName = rdr["VocabularyName"] == DBNull.Value ? string.Empty : rdr["VocabularyName"].ToString(),
State = rdr["State"] == DBNull.Value ? -1 : int.Parse(rdr["State"].ToString()),
Operator = rdr["Operator"] == DBNull.Value ? string.Empty : rdr["Operator"].ToString(),
OperatingTime = rdr["OperatingTime"] == DBNull.Value ? Convert.ToDateTime("1900-01-01") : DateTime.Parse(rdr["OperatingTime"].ToString())
};
list.Add(vocabularyInfo);
}
}
return(list);
}
public override VocabularyInfo Search(string word)
{
//回傳Model
VocabularyInfo searchRE = new VocabularyInfo();
// From Web
var url = searchUrl + word;
var web = new HtmlWeb();
var doc = web.Load(url);
var definSingleNode = doc.DocumentNode.SelectSingleNode("//div[@id='definition']");
if (definSingleNode == null)
{
return(null);
}
foreach (var node in definSingleNode.Descendants())
{
if (node.Name == "a") //替換為data-link
{
node.SetAttributeValue("data-link", _baseUrl + node.InnerHtml);
node.Attributes["href"].Value = "javascript:void(0)";
}
}
// 找到解釋
List <string> defins = new List <string>();
var filterHtml = definSingleNode.InnerHtml
.Replace("<h3>解釋</h3>", "<h3>")
.Replace("<h3>例句</h3>", "</h3>")
.Replace("<br>", "")
.Replace("\n", "|");
string pattern = "<h3>(.*?)</h3>";
MatchCollection matches = Regex.Matches(filterHtml, pattern);
Console.WriteLine("Matches found: {0}", matches.Count);
if (matches.Count > 0)
{
foreach (Match m in matches)
{
// 分割每個解釋
defins = m.Groups[1].ToString().Split('|').Select(w => w).ToList();
// 空白移除
defins.Remove("");
}
}
// 加入標題
HtmlNode titleNode = HtmlNode.CreateNode($"<h2>{word}</h2>");
definSingleNode.PrependChild(titleNode);
string html = definSingleNode.InnerHtml.Replace("\n", ""); // html格式 不需要換行
// 加到回傳Json內
searchRE.Word = word;
searchRE.ChineseDefin = defins;
searchRE.FullHtml = html;
return(searchRE);
}
public VocabRecord(VocabularyInfo vocabRecord)
{
_vocabRecord = vocabRecord;
}
