public static Result GetCachedResult(ServiceItem serviceItem, string phrase, LanguagePair languagesPair, string subject)
{
if(!useCache)
return new Result(serviceItem, phrase, languagesPair, subject);
string key = phrase.Trim().ToLowerInvariant();
if(key.Length > 500)
key = key.Substring(0, 500);
ResultsHashtable collection;
bool collection_exists = true;
lock(cache)
{
if(!cache.TryGetValue(key, out collection))
{
collection = new ResultsHashtable();
cache.Add(key, collection);
collection_exists = false;
}
}
int hash = Result.GetHashCode(serviceItem.FullName, languagesPair, subject);
bool needed_new_result = !collection_exists;
Result res = null;
lock(collection)
{
if(!needed_new_result)
{
if(!collection.TryGetValue(hash, out res))
needed_new_result = true;
else
{
needed_new_result = (res.Error != null && !res.ResultNotFound) || res.Phrase != phrase;
}
}
if(needed_new_result)
{
res = new Result(serviceItem, phrase, languagesPair, subject);
collection[hash] = res;
lock(results_history)
{
results_history.Add(res);
}
}
else
{
res.LastUsed = DateTime.Now;
lock(results_history)
{
results_history.Remove(res);
results_history.Add(res);
}
}
}
return res;
}
/// <summary>
/// Checks "WrongServiceItem" condition.
/// </summary>
private static void CheckServiceItem(ServiceItem serviceItem)
{
string serviceName = serviceItem.ServiceName;
string displayName = serviceItem.DisplayName;
StringBuilder message = new StringBuilder();
if (serviceName != Arguments.ServiceName)
{
message.AppendLine(
Errors.InvalidServiceName
.Display(
Arguments.ServiceName,
serviceName));
}
if (displayName != Arguments.DisplayName)
{
message.AppendLine(
Errors.InvalidDisplayName
.Display(
Arguments.DisplayName,
displayName));
}
if (message.Length > 0)
{
RaiseError.WrongServiceItem(message.ToString());
}
}
public DumpServiceWindow(ServiceItem item, MemoryObject serviceMo)
{
InitializeComponent();
this.AddEscapeToClose();
_serviceMo = serviceMo;
this.Text = "Service - " + item.Status.ServiceName;
labelServiceName.Text = item.Status.ServiceName;
labelServiceDisplayName.Text = item.Status.DisplayName;
textServiceType.Text = item.Config.ServiceType.ToString();
if (item.Config.ServiceType == (ServiceType.Win32OwnProcess | ServiceType.InteractiveProcess))
textServiceType.Text = "Win32OwnProcess, InteractiveProcess";
else if (item.Config.ServiceType == (ServiceType.Win32ShareProcess | ServiceType.InteractiveProcess))
textServiceType.Text = "Win32ShareProcess, InteractiveProcess";
textStartType.Text = item.Config.StartType.ToString();
textErrorControl.Text = item.Config.ErrorControl.ToString();
textLoadOrderGroup.Text = item.Config.LoadOrderGroup;
textServiceBinaryPath.Text = item.Config.BinaryPathName;
textUserAccount.Text = item.Config.ServiceStartName;
textServiceDll.Text = item.ServiceDll;
try
{
var dict = Dump.GetDictionary(_serviceMo);
if (dict.ContainsKey("Description"))
textDescription.Text = dict["Description"];
}
catch
{ }
}
private void btnSaveItem_Click(object sender, EventArgs e)
{
var servItem = new ServiceItem();
servItem.CarServiceID = chosenService.IDService;
servItem.Name = tbItemName.Text;
servItem.TotalPrice = int.Parse(tbPrice.Text);
int v = Ishod7.SaveItem(chosenService, servItem);
lblStatus.Text = $"Saved {v} service item.";
initServiceItems();
}
public async Task SaveServiceItem(ServiceItem serviceItem)
{
if (serviceItem.Id == default)
{
context.Entry(serviceItem).State = Microsoft.EntityFrameworkCore.EntityState.Added;
}
else
{
context.Entry(serviceItem).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
}
await context.SaveChangesAsync();
}
public static async Task <List <MediaList> > GetSeriesContentList(ServiceItem item)
{
try
{
return(await CurrentService.GetItemEpisodes(item) as List <MediaList>);
}
catch (Exception)
{
//offline mode, then.
return(new List <MediaList>());
}
}
public void SaveServiceItem(ServiceItem entity)
{
if (entity.Id == default) // тут перевіряєця що якщо це новий запис то для нього ще немає ІД і тому його треба створити
{
context.Entry(entity).State = EntityState.Added; // Added - це флаг що це новий обєкт в БД
}
else
{
context.Entry(entity).State = EntityState.Modified; // Added - це флаг що це не новий обєкт в БД і він змінений
}
context.SaveChanges();
}
public void SaveServiceItem(ServiceItem entity)
{
if (entity.Id == default)
{
context.Entry(entity).State = EntityState.Added;
}
else
{
context.Entry(entity).State = EntityState.Modified;
}
context.SaveChanges();
}
public async Task <ActionResult> Create([Bind(Include = "ServiceItemId,ServiceItemCode,ServiceItemName,Rate")] ServiceItem serviceItem)
{
if (ModelState.IsValid)
{
_applicationDbContext.ServiceItems.Add(serviceItem);
await _applicationDbContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(serviceItem));
}
private void Process_Exited(ServiceItem service, Process proc)
{
var sa = this.Analytics.Services.FirstOrDefault(a => a.ServiceID == service.ID);
if (sa != null)
{
sa.Exited = DateTime.Now;
}
var s = this.Config.ServiceList.FirstOrDefault(a => a.ID == sa.ServiceID);
if (s == null)
{
return;
}
sa.Status = ServiceAnalytics.eStatus.offline;
if (service.LogConsoleOutput)
{
//Save to harddrive
if (service.LogConsoleOutputToDisk && SaveToDisk(service, sa.Output))
{
sa.Output = "";
sa.LastSaved = DateTime.Now;
}
}
//if (LiveLogs.Contains(sa.ServiceID))
//{
// Connection.ServerChannel.LiveLogsUpdate(sa.ServiceID, "SERVICE MANAGER: Service has been ended");
//}
if (!service.ForceRestart | !this.IsRunning)
{
if (this.Config.Notifications.OnStop)
{
Extensions.Extensions.SendNotification(this.Config.Notifications.PluginId.Value, this.Config.Notifications.InstanceName + ": " + s.Title + "\r\nStatus: Stopped");
}
return;
}
sa.Restarts++;
StartService(service);
if (this.Config.Notifications.OnRestart)
{
Extensions.Extensions.GetExtension(this.Config.Notifications.PluginId)?.Notification?.Send(this.Config.Notifications.InstanceName + ": " + s.Title + "\r\nStatus: Restarted");
}
}
private void _provider_DictionaryModified(ServiceItem oldItem, ServiceItem newItem)
{
if (!this.IsHandleCreated)
{
return;
}
this.BeginInvoke(new MethodInvoker(() =>
{
// update the state of the service
if (listServices.Items.ContainsKey(newItem.Status.ServiceName))
{
listServices.Items[newItem.Status.ServiceName].SubItems[2].Text =
newItem.Status.ServiceStatusProcess.CurrentState.ToString();
}
// update the start and stop buttons if we have a service selected
if (listServices.SelectedItems.Count == 1)
{
if (listServices.SelectedItems[0].Name == newItem.Status.ServiceName)
{
buttonStart.Enabled = false;
buttonStop.Enabled = false;
switch (newItem.Status.ServiceStatusProcess.CurrentState)
{
case ServiceState.Running:
this.buttonStop.Enabled = true;
break;
case ServiceState.Stopped:
this.buttonStart.Enabled = true;
break;
}
}
}
// if the service was just started in this process, add it to the list
if (newItem.Status.ServiceStatusProcess.ProcessID == this.PID && oldItem.Status.ServiceStatusProcess.ProcessID == 0)
{
if (!listServices.Items.ContainsKey(newItem.Status.ServiceName))
{
listServices.Items.Add(new ListViewItem(new string[]
{
newItem.Status.ServiceName,
newItem.Status.DisplayName,
newItem.Status.ServiceStatusProcess.CurrentState.ToString()
})).Name = newItem.Status.ServiceName;
}
}
}));
}
// <summary>
// Delete Service Item by id
// </summary>
public void DeleteServiceItem(long serviceItemId)
{
ServiceItem dbversion = serviceItemRepository.Find((int)serviceItemId);
ValidateBeforeDeletion(serviceItemId);
if (dbversion == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Service Item with Id {0} not found!", serviceItemId));
}
serviceItemRepository.Delete(dbversion);
serviceItemRepository.SaveChanges();
}
/// <summary>
/// Create/Update a service.
/// </summary>
/// <param name="service">ServiceItem instance</param>
public void SaveServiceItem(ServiceItem service)
{
if (service.Id == default) //new service
{
context.Entry(service).State = EntityState.Added;
}
else
{
context.Entry(service).State = EntityState.Modified;
}
context.SaveChanges();
}
public void Create(ServiceItem serviceItem)
{
if (!Check(serviceItem.IdServiceItem))
{
db.context.ServiceItem.Add(serviceItem);
db.context.SaveChanges();
}
else
{
++serviceItem.IdServiceItem;
Create(serviceItem);
}
}
private void Bind()
{
//查询条件
GetSearchItem();
int totalRecords = 0;
ServiceItem bll = new ServiceItem();
rpData.DataSource = bll.GetListByJoin(pageIndex, pageSize, out totalRecords, sqlWhere, parms == null ? null : parms.ToArray());
rpData.DataBind();
myDataAppend += "<div id=\"myDataForPage\" style=\"display:none;\">[{\"PageIndex\":\"" + pageIndex + "\",\"PageSize\":\"" + pageSize + "\",\"TotalRecord\":\"" + totalRecords + "\",\"QueryStr\":\"" + queryStr + "\"}]</div>";
}
public void Installing_And_Uninstalling_Multiple_Service_NET_2()
{
const TargetFramework targetFramework = TargetFramework.Net20;
string binaryPathName = Path.Combine(
s_basePath,
"TestWindowsService.exe");
bool ok = CompileDynamic(
Resources.WindowsService2,
binaryPathName,
"v2.0.50727");
Assert.IsTrue(ok);
var services1 = ServiceHelper_Accessor.GetInstalledServices();
ServiceHelper_Accessor.InstallService(
targetFramework,
binaryPathName);
var services2 = ServiceHelper_Accessor.GetInstalledServices();
services2.ExceptWith(services1);
Assert.AreEqual(2, services2.Count);
ServiceItem serviceItemA = services2.First();
Assert.AreEqual("WindowsService2a", serviceItemA.ServiceName);
Assert.AreEqual("[Test] Windows Service #2-A", serviceItemA.DisplayName);
string actualBinaryPathNameA = ServiceHelper_Accessor.GetInstalledServiceBinaryPathName("WindowsService2a");
Assert.AreEqual(binaryPathName, actualBinaryPathNameA);
ServiceItem serviceItemB = services2.Last();
Assert.AreEqual("WindowsService2b", serviceItemB.ServiceName);
Assert.AreEqual("[Test] Windows Service #2-B", serviceItemB.DisplayName);
string actualBinaryPathNameB = ServiceHelper_Accessor.GetInstalledServiceBinaryPathName("WindowsService2a");
Assert.AreEqual(binaryPathName, actualBinaryPathNameB);
ServiceHelper_Accessor.UninstallService(
targetFramework,
binaryPathName);
File.Delete(binaryPathName);
}
private void ServiceItem_EnableClickEvent(ServiceItem serviceItem)
{
ModuleInfo item = (ModuleInfo)serviceItem.Tag;
if (item.Enabled == 0)
{
// ENABLE
AdminNetwork.SendEnableService(item.Id);
}
else
{
AdminNetwork.SendDisableService(item.Id);
}
}
/// <summary>
/// 移除一个项目
/// </summary>
/// <param name="ItemId"></param>
public void RemoveServiceItems(int ItemId)
{
ServiceItem item = itemController.GetServiceItemById(ItemId);
string message;
if (itemController.CheckServiceItemReferencedBeforeRemove(item, out message))
{
itemController.RemoveServiceItemFromHospital(item);
}
else
{
throw new CustomException(message);
}
}
public override string GetAuthKey(ServiceItem item)
{
#pragma warning disable
var itemAds = (item as AdsServiceItem);
#pragma warning restore
#if UNITY_IOS
return(itemAds.iosKey);
#elif UNITY_ANDROID
return(itemAds.androidKey);
#else
return(item.authKey);
#endif
}
// GET: ServiceItems/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ServiceItem serviceItem = await _applicationDbContext.ServiceItems.FindAsync(id);
if (serviceItem == null)
{
return(HttpNotFound());
}
return(View(serviceItem));
}
public void Installing_And_Uninstalling_Single_Service_NET_4()
{
const TargetFramework targetFramework = TargetFramework.Net40;
string binaryPathName = Path.Combine(
s_basePath,
"TestWindowsService.exe");
bool ok = CompileDynamic(
Resources.WindowsService1,
binaryPathName,
"v4.0.30319");
Assert.IsTrue(ok);
var services1 = ServiceHelper_Accessor.GetInstalledServices();
ServiceHelper_Accessor.InstallService(
targetFramework,
binaryPathName);
var services2 = ServiceHelper_Accessor.GetInstalledServices();
services2.ExceptWith(services1);
Assert.AreEqual(
1,
services2.Count);
ServiceItem serviceItem = services2.First();
Assert.AreEqual(
"WindowsService1",
serviceItem.ServiceName);
Assert.AreEqual(
"[Test] Windows Service #1",
serviceItem.DisplayName);
string actualBinaryPathName =
ServiceHelper_Accessor.GetInstalledServiceBinaryPathName("WindowsService1");
Assert.AreEqual(binaryPathName, actualBinaryPathName);
ServiceHelper_Accessor.UninstallService(
targetFramework,
binaryPathName);
File.Delete(binaryPathName);
}
public void ServiceItemSelected(object obj)
{
if (obj.GetType() == typeof(ServiceItem))
{
ClearOutput();
lastLogReceived = -1; // Reset log
ServiceItem listItem = obj as ServiceItem;
ModuleInfo item = (ModuleInfo)listItem.Tag;
selectedService = listItem;
ManualUpdate();
}
}
protected void btnSave_Click(object sender, EventArgs e)
{
using (var context = new PPPKContext())
{
ServiceItem s = context.ServiceItem.Find(int.Parse(ddlServiceItem.SelectedValue));
s.Price = Decimal.Parse(txtPrice.Text);
s.ServiceName = txtServiceName.Text;
s.ServiceID = int.Parse(ddlService.SelectedValue);
context.SaveChanges();
context.Dispose();
}
InitVehicles();
}
void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
var list = DeserializeServiceItems();
if (list != null)
{
foreach (var s in list)
{
var serviceitem = new ServiceItem(s);
serviceitem.IdentityName = Login.CurrentLoginUserName;
serviceitem.ServiceConnState = ConnectState.Disconnected;
services.Add(serviceitem);
}
}
}
private void Addconnect(Service service)
{
var s = services.Where(o => o.ServiceAddress == service.ServiceAddress).FirstOrDefault();
if (s == null)
{
var serviceitem = new ServiceItem(service);
serviceitem.NickName = serviceitem.Text;
services.Add(serviceitem);
SerializeServiceItems();
}
else
{
s.IsSelected = true;
}
}
private void BindEdit()
{
Guid Id = Guid.Empty;
if (!string.IsNullOrWhiteSpace(Request.QueryString["Id"]))
{
Guid.TryParse(Request.QueryString["Id"], out Id);
}
if (!Id.Equals(Guid.Empty))
{
ServiceItem bll = new ServiceItem();
var model = bll.GetModelByJoin(Id);
if (model != null)
{
hId.Value = model.Id.ToString();
if (!string.IsNullOrWhiteSpace(model.ParentName))
{
lbParent.InnerText = model.ParentName;
hParentId.Value = model.ParentId.ToString();
}
else
{
lbParent.InnerText = "分类根";
hParentId.Value = Guid.Empty.ToString();
}
txtName.Value = model.Named;
string pictureUrl = "";
if (!string.IsNullOrWhiteSpace(model.FileDirectory))
{
pictureUrl = PictureUrlHelper.GetMPicture(model.FileDirectory, model.RandomFolder, model.FileExtension);
}
imgServicePicture.Src = string.IsNullOrWhiteSpace(pictureUrl) ? "../../Images/nopic.gif" : pictureUrl;
hImgServicePictureId.Value = model.PictureId.ToString();
txtSort.Value = model.Sort.ToString();
txtEnableStartTime.Value = model.EnableStartTime == DateTime.MinValue ? "" : model.EnableStartTime.ToString("yyyy-MM-dd HH:mm:ss");
txtEnableEndTime.Value = model.EnableEndTime == DateTime.MinValue ? "" : model.EnableStartTime.ToString("yyyy-MM-dd HH:mm:ss");
var li = rbtnList.Items.FindByValue(model.IsDisable.ToString().ToLower());
if (li != null)
{
li.Selected = true;
}
}
}
}
public IActionResult Edit(ServiceItem model, IFormFile titleImageFile)
{
if (ModelState.IsValid)
{
if (titleImageFile != null)
{
model.TitleImagePath = titleImageFile.FileName;
using (var stream = new FileStream(Path.Combine(hostingEnvironment.WebRootPath, "images/", titleImageFile.FileName), FileMode.Create))
{
titleImageFile.CopyTo(stream);
}
}
dataManager.ServiceItems.SafeServiceItem(model);
return(RedirectToAction(nameof(HomeController.Index), nameof(HomeController).CutController()));
}
return(View(model));
}
public async Task <IActionResult> AddServiceItem([FromBody] ServiceItem schedulableCatalogItem)
{
var item = new ServiceItem(schedulableCatalogItem.SiteId,
schedulableCatalogItem.Name,
schedulableCatalogItem.Description,
schedulableCatalogItem.DefaultTimeLength,
schedulableCatalogItem.Price,
schedulableCatalogItem.ServiceCategoryId,
schedulableCatalogItem.IndustryStandardCategoryName,
schedulableCatalogItem.IndustryStandardSubcategoryName);
_catalogContext.ServiceItems.Add(item);
await _catalogContext.SaveChangesAsync();
return(CreatedAtAction(nameof(FindServiceItemById), new { id = item.Id }, null));
}
/// <summary>
/// 获取到服务版本信息
/// </summary>
/// <param name="serviceName"></param>
/// <param name="version"></param>
/// <returns></returns>
private ServiceItem GetServiceItem(String serviceName, Int32 version)
{
Boolean getSyncESBConfig = false;
if (ESBConfig == null)
{
SyncESBConfig(serviceName);
getSyncESBConfig = true;
}
if (ESBConfig == null)
{
throw new Exception("无法获取到有效的配置文件");
}
//--从ESBConfig中获取到服务版本信息
ServiceItem si = this.ESBConfig.GetInvokeServiceItem(serviceName, version);
if (si == null)
{
if (getSyncESBConfig)//--如果已经获取过ESBConfig文件则直接抛出异常
{
m_ConfigurationManager.RemoveReference(serviceName, m_ConsumerConfig);
throw new Exception(String.Format("请求的服务【{0}】的【{1}】版本没有注册或者已经废弃!", serviceName, version == 0 ? "默认" : version.ToString()));
}
else
{
SyncESBConfig(serviceName);
si = this.ESBConfig.GetInvokeServiceItem(serviceName, version);
if (si == null)
{
m_ConfigurationManager.RemoveReference(serviceName, m_ConsumerConfig);
throw new Exception(String.Format("请求的服务【{0}】的【{1}】版本没有注册或者已经废弃!", serviceName, version == 0 ? "默认" : version.ToString()));
}
}
}
if (si.Binding == null || si.Binding.Count == 0)
{
throw new Exception(String.Format("请求的服务【{0}】没有有效的绑定地址!", serviceName));
}
return(si);
}
public IActionResult Edit(ServiceItem serviceItem, IFormFile titleImageFile)
{
if (ModelState.IsValid)
{
if (titleImageFile != null)
{
serviceItem.TitleImage = titleImageFile.FileName;
using var fs = new FileStream(Path.Combine(hostEnvironment.WebRootPath, "images/serviceImages/",
titleImageFile.FileName), FileMode.Create);
titleImageFile.CopyTo(fs);
}
dataManager.ServiceItems.SaveServiceItem(serviceItem);
return(RedirectToAction(nameof(HomeController.Index), nameof(HomeController).CutController()));
}
return(View(serviceItem));
}
private void lvwNonFoodSvcItems_ItemChecked(object sender, ItemCheckedEventArgs e)
{
if (loadingControls == false)
{
int SvcItemId = Int32.Parse(e.Item.SubItems[2].Text.ToString());
ServiceItem si = CCFBGlobal.clsDailyItems.NonFoodItemsList.Find(delegate(ServiceItem si0) { return(si0.ItemKey == SvcItemId); });
if (si != null)
{
si.IsSelected = e.Item.Checked;
btnSave.Enabled = true;
SumNonFoodServiceItems();
ShowNonFoodLbs();
}
else
{
}
}
}
public string DelServiceItem(string id)
{
if (string.IsNullOrWhiteSpace(id))
{
return(MessageContent.Submit_InvalidRow);
}
Guid gId = Guid.Empty;
Guid.TryParse(id, out gId);
if (gId.Equals(Guid.Empty))
{
return(MessageContent.GetString(MessageContent.Submit_Params_GetInvalidRegex, "对应标识值"));
}
ServiceItem bll = new ServiceItem();
bll.DeleteByJoin(gId);
return("1");
}
public DiagnosticServiceProvider(IServiceCollection services)
{
items = new Dictionary <Type, List <ServiceItem> >();
foreach (var item in services)
{
if (!items.TryGetValue(item.ServiceType, out var list))
{
list = new List <ServiceItem>();
items.Add(item.ServiceType, list);
}
var serviceItem = new ServiceItem(item)
{
Item = item.ImplementationInstance
};
list.Add(serviceItem);
}
}
static void AddLangPairServiceItem(LanguagePair langPair, ServiceItem serviceItem)
{
ServiceItemsCollection serviceItems_list;
if(!langpair_serviceItems.TryGetValue(langPair, out serviceItems_list))
{
serviceItems_list = new ServiceItemsCollection();
langpair_serviceItems.Add(langPair, serviceItems_list);
}
serviceItems_list.Add(serviceItem);
}
public static List<ServiceItem> GetServicesByName(string searchPattern, int userId)
{
SqlConnection conn = null;
SqlDataReader dr = null;
List<ServiceItem> results = new List<ServiceItem>();
try
{
conn = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["DataServices"].ConnectionString);
conn.Open();
SqlCommand cmd = new SqlCommand("GetServicesByName", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@name", searchPattern);
cmd.Parameters.AddWithValue("@userId", userId);
dr = cmd.ExecuteReader();
while (dr.Read())
{
ServiceItem l = new ServiceItem();
l.id = dr.GetInt32(0);
l.name = dr.GetValue(1).ToString();
l.description = dr.GetValue(2).ToString();
l.code = dr.GetValue(3).ToString();
l.codeType = dr.GetValue(4).ToString();
l.issuerCountryCode = dr.GetValue(5).ToString();
l.issuerCountry = dr.GetValue(6).ToString();
//l.manufacturerid = dr.GetValue(7).ToString();
//l.modelNum = dr.GetValue(8).ToString();
l.status = "success";
int cId = -1;
int.TryParse(dr.GetValue(7).ToString(), out cId);
if (cId > 0)
l.companyId = cId;
l.companyName = dr.GetValue(8).ToString();
l.numReviews = dr.GetInt32(9);
l.compositRating = dr.GetDouble(10);
l.hasReviewed = Convert.ToBoolean(dr.GetInt32(11));
l.hasReviewedId = dr.GetInt32(12);
results.Add(l);
}
return results;
}
catch (Exception e)
{
Dimmi.Data.Log.WriteDataToLog("GetServicesByName", e);
return null;
}
finally
{
if (dr != null)
{
dr.Close();
}
if (conn != null)
{
conn.Close();
}
}
}
public void serviceP_DictionaryRemoved(ServiceItem item)
{
this.QueueMessage("Deleted Service: " + item.Status.ServiceName +
" (" + item.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
((item.Status.DisplayName != "") ?
" (" + item.Status.DisplayName + ")" :
""));
if (DSMenuItem.Checked)
this.GetFirstIcon().ShowBalloonTip(2000, "Service Deleted",
"The service " + item.Status.ServiceName + " (" + item.Status.DisplayName + ") has been deleted.",
ToolTipIcon.Info);
}
public static void DoTranslate(ServiceItem serviceItem, string phrase, LanguagePair languagesPair, string subject, Result result, NetworkSetting networkSetting)
{
bool synonimsDictionary = languagesPair.From == Language.Polish && languagesPair.To == Language.Polish;
string query = "http://megaslownik.pl/slownik/{0}/,{1}";
query = string.Format(query,
MegaslownikTools.ConvertLanguagePair(languagesPair),
HttpUtility.UrlEncode(phrase));
result.ArticleUrl = query;
result.ArticleUrlCaption = phrase;
WebRequestHelper helper =
new WebRequestHelper(result, new Uri(query),
networkSetting,
WebRequestContentType.UrlEncodedGet);
string responseFromServer = helper.GetResponse();
if(responseFromServer.Contains("<div class=\"slowo\">\r\n Szukanego słowa nie ma w MEGAsłowniku.\r\n"))
{
result.ResultNotFound = true;
throw new TranslationException("Nothing found");
}
result.HasAudio = responseFromServer.Contains("class=\"ikona_sluchaj2\">");
string[] translations = StringParser.ParseItemsList("<div class=\"definicja\">", "</div>", responseFromServer);
if(translations.Length == 0)
{
result.ResultNotFound = true;
throw new TranslationException("Nothing found");
}
string subsubtranslation;
string[] subtranslations;
foreach(string translation in translations)
{
subtranslations = StringParser.ParseItemsList("<a href=\"/slownik", "</a>", translation);
foreach(string subtranslation in subtranslations)
{
subsubtranslation = StringParser.ExtractRight(">", subtranslation);
subsubtranslation = StringParser.RemoveAll("<", ">", subsubtranslation);
result.Translations.Add(subsubtranslation);
}
}
//synonims
translations = StringParser.ParseItemsList("<div class=\"synonim\">synonimy:", "</div>", responseFromServer);
foreach(string translation in translations)
{
subtranslations = StringParser.ParseItemsList("<a href=\"/slownik", "</a>", translation);
foreach(string subtranslation in subtranslations)
{
subsubtranslation = StringParser.ExtractRight(">", subtranslation);
subsubtranslation = StringParser.RemoveAll("<", ">", subsubtranslation);
if(!result.Translations.Contains(subsubtranslation))
result.Translations.Add(subsubtranslation);
}
}
//additional links
if(!synonimsDictionary)
{
string[] links = StringParser.ParseItemsList("<li ><a href=\"/slownik/", "</li>", responseFromServer);
string linkUrl, linkText, subphrase, subtrans;
Result child;
foreach(string link in links)
{
linkUrl = "http://megaslownik.pl/slownik/" + StringParser.ExtractLeft("\"", link);
linkText = StringParser.ExtractRight(">", link);
linkText = StringParser.RemoveAll("<", ">", linkText);
if(linkText.Contains("»") && linkText.Contains(phrase))
{
subphrase = StringParser.ExtractLeft("»", linkText);
subtrans = StringParser.ExtractRight("»", linkText);
child = serviceItem.CreateNewResult(subphrase, languagesPair, subject);
result.Childs.Add(child);
child.Translations.Add(subtrans);
child.ArticleUrl = linkUrl;
child.ArticleUrlCaption = subphrase;
}
}
links = StringParser.ParseItemsList("<li><a href=\"/slownik/", "</li>", responseFromServer);
foreach(string link in links)
{
linkUrl = "http://megaslownik.pl/slownik/" + StringParser.ExtractLeft("\"", link);
linkText = StringParser.ExtractRight(">", link);
linkText = StringParser.RemoveAll("<", ">", linkText);
if(linkText.Contains("»") && linkText.Contains(phrase))
{
subphrase = StringParser.ExtractLeft("»", linkText);
subtrans = StringParser.ExtractRight("»", linkText);
child = serviceItem.CreateNewResult(subphrase, languagesPair, subject);
result.Childs.Add(child);
child.Translations.Add(subtrans);
child.ArticleUrl = linkUrl;
child.ArticleUrlCaption = subphrase;
}
//result.RelatedLinks.Add(linkText, linkUrl);
}
}
else
{ //synonyms
string[] links = StringParser.ParseItemsList("<li ><a href=\"/slownik/", "</li>", responseFromServer);
string linkUrl, linkText;
foreach(string link in links)
{
linkUrl = "http://megaslownik.pl/slownik/" + StringParser.ExtractLeft("\"", link);
linkText = StringParser.ExtractRight(">", link);
linkText = StringParser.RemoveAll("<", ">", linkText);
if(linkText.Contains(phrase))
result.RelatedLinks.Add(linkText, linkUrl);
}
links = StringParser.ParseItemsList("<li><a href=\"/slownik/", "</li>", responseFromServer);
foreach(string link in links)
{
linkUrl = "http://megaslownik.pl/slownik/" + StringParser.ExtractLeft("\"", link);
linkText = StringParser.ExtractRight(">", link);
linkText = StringParser.RemoveAll("<", ">", linkText);
if(linkText.Contains(phrase))
result.RelatedLinks.Add(linkText, linkUrl);
}
}
}
static void GenerateServiceItemSell(WebBrowser wBrowser, ServiceItem si, string parentName, bool first, bool generateLangs)
{
StringBuilder htmlString = new StringBuilder();
htmlString.AppendFormat(CultureInfo.InvariantCulture,
HtmlHelper.ServiceNameFormat,
si.Service.Url,
HttpUtility.HtmlEncode(si.Service.Url.AbsoluteUri));
htmlString.Append(", ");
if(!string.IsNullOrEmpty(si.Description))
htmlString.Append(LangPack.TranslateString(si.Description) + " - ");
htmlString.Append(LangPack.TranslateString(si.Service.FullName));
if(si is MonolingualDictionary)
{
htmlString.Append(", ");
htmlString.Append(LangPack.TranslateLanguage(si.SupportedTranslations[0].From));
}
htmlString.Append(", ");
htmlString.Append(ServiceSettingsContainer.GetServiceItemType(si));
if(si.SupportedSubjects.Count > 1)
{
htmlString.Append(", " + LangPack.TranslateString("Subjects") + " : ");
htmlString.Append(LangPack.TranslateString(SubjectConstants.Common));
foreach(string subject in si.SupportedSubjects)
{
if(subject != SubjectConstants.Common)
{
htmlString.Append(", ");
htmlString.Append(LangPack.TranslateString(subject));
}
}
}
htmlString.Append(", ");
htmlString.Append(HttpUtility.HtmlEncode(si.Service.Copyright));
if(si is MonolingualDictionary || !generateLangs)
{
HtmlHelper.AddTranslationCell(wBrowser, parentName, first, htmlString.ToString(), si, true);
return;
}
//count langs without gb\us english
int pairsCount = 0;
foreach(LanguagePair lp in si.SupportedTranslations)
{
if(lp.From != Language.English_GB && lp.From != Language.English_US &&
lp.To != Language.English_GB && lp.To != Language.English_US)
pairsCount ++;
}
string langNodeName = si.FullName + "_langs";
htmlString.Append("<br>" + GenerateTopNode(langNodeName, LangPack.TranslateString("Languages") + GetLangsPairsCount(pairsCount), 0.5));
HtmlHelper.AddTranslationCell(wBrowser, parentName, first, htmlString.ToString(), si, true);
SortedDictionary<string, SortedDictionary<string, string>> langs = new SortedDictionary<string, SortedDictionary<string, string>>();
foreach(LanguagePair lp in si.SupportedTranslations)
{
if(lp.From == Language.English_GB || lp.From == Language.English_US ||
lp.To == Language.English_GB || lp.To == Language.English_US)
continue;
string fromlang = LangPack.TranslateLanguage(lp.From);
SortedDictionary<string, string> inner_list;
if(!langs.TryGetValue(fromlang, out inner_list))
{
inner_list = new SortedDictionary<string, string>();
langs.Add(fromlang, inner_list);
}
inner_list.Add(LangPack.TranslateLanguage(lp.To), "");
}
if(si.SupportedTranslations.Count <= 10)
{
htmlString = new StringBuilder();
foreach(KeyValuePair<string, SortedDictionary<string, string>> kvp_langs in langs)
{
foreach(KeyValuePair<string, string> kvp_to_langs in kvp_langs.Value)
{
htmlString.Append("<li>" + kvp_langs.Key + "->" + kvp_to_langs.Key + "</li>");
}
}
HtmlHelper.SetNodeInnerHtml(wBrowser, langNodeName, htmlString.ToString());
}
else
{
htmlString = new StringBuilder();
foreach(KeyValuePair<string, SortedDictionary<string, string>> kvp_langs in langs)
{
string nodeName = si.FullName + "_lang_" + kvp_langs.Key;
nodeName = nodeName.Replace("'", "_");
htmlString.Append(GenerateTopNode(nodeName, kvp_langs.Key + "->" + GetLangsPairsCount(kvp_langs.Value.Count) , 1));
}
HtmlHelper.SetNodeInnerHtml(wBrowser, langNodeName, htmlString.ToString());
foreach(KeyValuePair<string, SortedDictionary<string, string>> kvp_langs in langs)
{
string nodeName = si.FullName + "_lang_" + kvp_langs.Key;
nodeName = nodeName.Replace("'", "_");
htmlString = new StringBuilder();
foreach(KeyValuePair<string, string> kvp_to_langs in kvp_langs.Value)
{
htmlString.Append("<li>" + kvp_to_langs.Key + "</li>");
}
HtmlHelper.SetNodeInnerHtml(wBrowser, nodeName, htmlString.ToString());
}
}
}
public static void InitServiceItem(ServiceItem serviceItem)
{
serviceItem.CharsLimit = 3000;
serviceItem.AddSupportedSubject(SubjectConstants.Common);
}
private void provider_DictionaryRemoved(ServiceItem item)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new ServiceProvider.ProviderDictionaryRemoved(provider_DictionaryRemoved), item);
return;
}
lock (listServices)
listServices.Items[item.Status.ServiceName].Remove();
}
public void AddItem(ServiceItem item)
{
provider_DictionaryAdded(item);
}
public void ShowProperties(IWin32Window owner, ServiceItem item)
{
DumpServiceWindow dsw = new DumpServiceWindow(item, _servicesMo.GetChild(item.Status.ServiceName));
dsw.ShowDialog(owner);
}
private void LoadService(MemoryObject mo)
{
ServiceItem item = new ServiceItem();
var dict = Dump.GetDictionary(mo);
item.Status.ServiceName = dict["Name"];
item.Status.DisplayName = dict["DisplayName"];
item.Status.ServiceStatusProcess.ControlsAccepted = (ServiceAccept)Dump.ParseInt32(dict["ControlsAccepted"]);
item.Status.ServiceStatusProcess.CurrentState = (ServiceState)Dump.ParseInt32(dict["State"]);
item.Status.ServiceStatusProcess.ProcessID = Dump.ParseInt32(dict["ProcessId"]);
item.Status.ServiceStatusProcess.ServiceFlags = (ServiceFlags)Dump.ParseInt32(dict["Flags"]);
item.Status.ServiceStatusProcess.ServiceType = (ServiceType)Dump.ParseInt32(dict["Type"]);
if (dict.ContainsKey("BinaryPath"))
{
item.Config.BinaryPathName = dict["BinaryPath"];
item.Config.DisplayName = item.Status.DisplayName;
item.Config.ErrorControl = (ServiceErrorControl)Dump.ParseInt32(dict["ErrorControl"]);
item.Config.LoadOrderGroup = dict["Group"];
item.Config.ServiceStartName = dict["UserName"];
item.Config.ServiceType = item.Status.ServiceStatusProcess.ServiceType;
item.Config.StartType = (ServiceStartType)Dump.ParseInt32(dict["StartType"]);
if (dict.ContainsKey("ServiceDll"))
item.ServiceDll = dict["ServiceDll"];
}
_services.Add(item.Status.ServiceName, item);
listServices.AddItem(item);
if (item.Status.ServiceStatusProcess.ProcessID != 0)
{
if (!_processServices.ContainsKey(item.Status.ServiceStatusProcess.ProcessID))
_processServices.Add(item.Status.ServiceStatusProcess.ProcessID, new List<string>());
_processServices[item.Status.ServiceStatusProcess.ProcessID].Add(item.Status.ServiceName);
}
}
private void _provider_DictionaryModified(ServiceItem oldItem, ServiceItem newItem)
{
if (!this.IsHandleCreated)
return;
this.BeginInvoke(new MethodInvoker(() =>
{
// update the state of the service
if (listServices.Items.ContainsKey(newItem.Status.ServiceName))
listServices.Items[newItem.Status.ServiceName].SubItems[2].Text =
newItem.Status.ServiceStatusProcess.CurrentState.ToString();
// update the start and stop buttons if we have a service selected
if (listServices.SelectedItems.Count == 1)
{
if (listServices.SelectedItems[0].Name == newItem.Status.ServiceName)
{
buttonStart.Enabled = false;
buttonStop.Enabled = false;
switch (newItem.Status.ServiceStatusProcess.CurrentState)
{
case ServiceState.Running:
this.buttonStop.Enabled = true;
break;
case ServiceState.Stopped:
this.buttonStart.Enabled = true;
break;
}
}
}
// if the service was just started in this process, add it to the list
if (newItem.Status.ServiceStatusProcess.ProcessID == this.PID && oldItem.Status.ServiceStatusProcess.ProcessID == 0)
{
if (!listServices.Items.ContainsKey(newItem.Status.ServiceName))
{
listServices.Items.Add(new ListViewItem(new string[]
{
newItem.Status.ServiceName,
newItem.Status.DisplayName,
newItem.Status.ServiceStatusProcess.CurrentState.ToString()
})).Name = newItem.Status.ServiceName;
}
}
}));
}
static void AddServiceItem(ServiceItem serviceItem)
{
serviceItems.Add(serviceItem);
int index;
foreach(string subject in serviceItem.SupportedSubjects)
{
index = subjects.BinarySearch(subject);
if(index < 0)
subjects.Insert(~index, subject);
}
}
public void serviceP_DictionaryModified(ServiceItem oldItem, ServiceItem newItem)
{
var oldState = oldItem.Status.ServiceStatusProcess.CurrentState;
var newState = newItem.Status.ServiceStatusProcess.CurrentState;
if ((oldState == ServiceState.Paused || oldState == ServiceState.Stopped ||
oldState == ServiceState.StartPending) &&
newState == ServiceState.Running)
{
this.QueueMessage("Service Started: " + newItem.Status.ServiceName +
" (" + newItem.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
((newItem.Status.DisplayName != "") ?
" (" + newItem.Status.DisplayName + ")" :
""));
if (startedSMenuItem.Checked)
this.GetFirstIcon().ShowBalloonTip(2000, "Service Started",
"The service " + newItem.Status.ServiceName + " (" + newItem.Status.DisplayName + ") has been started.",
ToolTipIcon.Info);
}
if (oldState == ServiceState.Running &&
newState == ServiceState.Paused)
this.QueueMessage("Service Paused: " + newItem.Status.ServiceName +
" (" + newItem.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
((newItem.Status.DisplayName != "") ?
" (" + newItem.Status.DisplayName + ")" :
""));
if (oldState == ServiceState.Running &&
newState == ServiceState.Stopped)
{
this.QueueMessage("Service Stopped: " + newItem.Status.ServiceName +
" (" + newItem.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
((newItem.Status.DisplayName != "") ?
" (" + newItem.Status.DisplayName + ")" :
""));
if (stoppedSMenuItem.Checked)
this.GetFirstIcon().ShowBalloonTip(2000, "Service Stopped",
"The service " + newItem.Status.ServiceName + " (" + newItem.Status.DisplayName + ") has been stopped.",
ToolTipIcon.Info);
}
}
/// <summary>
/// Parses output of "sc query" command to extract currently installed services.
/// </summary>
private static HashSet<ServiceItem> ParseServicesOutput(string output)
{
HashSet<ServiceItem> serviceItemSet = new HashSet<ServiceItem>();
foreach (Match match in s_serviceItemRegex.Matches(output))
{
string serviceName = match.Groups["serviceName"].Value;
string displayName = match.Groups["displayName"].Value;
ServiceItem sp = new ServiceItem { ServiceName = serviceName, DisplayName = displayName };
serviceItemSet.Add(sp);
}
return serviceItemSet;
}
private void _provider_DictionaryRemoved(ServiceItem item)
{
this.BeginInvoke(new MethodInvoker(() =>
{
// remove the item from the list if it's there
if (listServices.Items.ContainsKey(item.Status.ServiceName))
listServices.Items[item.Status.ServiceName].Remove();
}));
}
public static void DoTranslate(ServiceItem serviceItem, string host, string bookName, string phrase, LanguagePair languagesPair, string subject, Result result, NetworkSetting networkSetting)
{
string query = host + "/{0}";
//ISO-8859-1
query = string.Format(query, HttpUtility.UrlEncode(phrase, System.Text.Encoding.UTF8 ));
WebRequestHelper helper =
new WebRequestHelper(result, new Uri(query),
networkSetting,
WebRequestContentType.UrlEncodedGet);
//helper.UseGoogleCache = true;
string responseFromServer = helper.GetResponse();
if(responseFromServer.IndexOf("The word you've entered isn't in the dictionary.") >= 0
|| responseFromServer.IndexOf("No entries found.\n<br/>") >= 0
|| responseFromServer.IndexOf("The word you've entered isn't in the thesaurus.") >= 0
)
{
if(responseFromServer.IndexOf("<PRE>") >= 0)
{ //suggestions
StringParser suggestions_parser = new StringParser("<PRE>", "</PRE>", responseFromServer);
string[] suggestions = suggestions_parser.ReadItemsList(">", "</a>");
foreach(string item in suggestions)
{
string part = item;
string link = "html!<p><a href=\""+ host + "/{0}\" title=\""+ host + "/{0}\">{0}</a></p>";
link = string.Format(link,
part);
result.Translations.Add(link);
}
return;
}
else
{
result.ResultNotFound = true;
throw new TranslationException("Nothing found");
}
}
result.ArticleUrl = host + "/" + phrase;
if(responseFromServer.Contains("One entry found.\n<br/>") || responseFromServer.Contains("One entry found.\n<br />"))
{
SetResult(result, responseFromServer, host + "/");
}
else
{
if(responseFromServer.Contains("'list' value=\"va:"))
{
string count_str = StringParser.Parse("'list' value=\"va:", ",", responseFromServer);
int count;
if(int.TryParse(count_str, out count))
result.MoreEntriesCount = count;
}
StringParser parser = new StringParser("<ol class=\"results\"", "</ol>", responseFromServer);
string[] items = parser.ReadItemsList("href=\"/" + bookName.ToLower() + "/", "\"");
bool first = true;
foreach(string item in items)
{
string part = item;
string part_name = StringParser.RemoveAll("[", "]", part);
if(string.Compare(part_name, phrase, true) == 0)
{
Result subres = serviceItem.CreateNewResult(part_name, languagesPair, subject);
result.Childs.Add(subres);
subres.ArticleUrl = host + "/" + part;
if(first)
{
SetResult(subres, responseFromServer, host + "/");
first = false;
}
else
{ //get translation
//jump=blood%5B1%2Cnoun%5D&book=Dictionary&quer=blood&list=45%2C1%2C3602592%2C0%3Bblood%5B1%2Cnoun%5D%3D113554%3Bblood%5B2%2Ctransitive+verb%5D%3D113572%3BABO+blood+group%3D2000002431%3Bbad+blood%3D2000074812%3Bblood-and-guts%3D2000113598%3Bblood-brain+barrier%3D2000113627%3Bblood+brother%3D2000113664%3Bblood+cell%3D2000113685%3Bblood+count%3D2000113697%3Bblood+doping%3D2000113725
/*string quer_value = StringParser.Parse("<input type='hidden' name='quer' value=\"", "\"", responseFromServer);
string list_value = StringParser.Parse("<input type='hidden' name='list' value=\"", "\"", responseFromServer);
string post_data_value = "jump={0}&book=" + bookName + "&quer={1}&list={2}";
post_data_value = string.Format(post_data_value ,
HttpUtility.UrlEncode(part),
HttpUtility.UrlEncode(quer_value),
HttpUtility.UrlEncode(list_value)
);
*/
helper =
new WebRequestHelper(result, new Uri(subres.ArticleUrl),
networkSetting,
WebRequestContentType.UrlEncodedGet);
//helper.AddPostData(post_data_value);
//helper.UseGoogleCache = true;
responseFromServer = helper.GetResponse();
SetResult(subres, responseFromServer, host + "/");
}
}
}
if(result.MoreEntriesCount != 0)
result.MoreEntriesCount -= result.Childs.Count;
}
}
private void provider_DictionaryModified(ServiceItem oldItem, ServiceItem newItem)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new ServiceProvider.ProviderDictionaryModified(provider_DictionaryModified), oldItem, newItem);
return;
}
lock (listServices)
{
ListViewItem litem = listServices.Items[newItem.Status.ServiceName];
if (litem == null)
return;
litem.SubItems[1].Text = newItem.Status.DisplayName;
litem.SubItems[2].Text = newItem.Status.ServiceStatusProcess.ServiceType.ToString();
litem.SubItems[3].Text = newItem.Status.ServiceStatusProcess.CurrentState.ToString();
litem.SubItems[4].Text = newItem.Config.StartType.ToString();
litem.SubItems[5].Text = newItem.Status.ServiceStatusProcess.ProcessID == 0 ? string.Empty :
newItem.Status.ServiceStatusProcess.ProcessID.ToString();
_needsSort = true;
}
}
public void serviceP_DictionaryAdded_Process(ServiceItem item)
{
if (item.Status.ServiceStatusProcess.ProcessID != 0)
{
if (!processServices.ContainsKey(item.Status.ServiceStatusProcess.ProcessID))
processServices.Add(item.Status.ServiceStatusProcess.ProcessID, new List<string>());
processServices[item.Status.ServiceStatusProcess.ProcessID].Add(item.Status.ServiceName);
}
}
public static string GetServiceIconCellHtml(ServiceItem serviceItem)
{
return GetServiceIconCellHtml(serviceItem, false);
}
public void serviceP_DictionaryModified_Process(ServiceItem oldItem, ServiceItem newItem)
{
ServiceItem sitem = (ServiceItem)newItem;
if (sitem.Status.ServiceStatusProcess.ProcessID != 0)
{
if (!processServices.ContainsKey(sitem.Status.ServiceStatusProcess.ProcessID))
processServices.Add(sitem.Status.ServiceStatusProcess.ProcessID, new List<string>());
if (!processServices[sitem.Status.ServiceStatusProcess.ProcessID].Contains(
sitem.Status.ServiceName))
processServices[sitem.Status.ServiceStatusProcess.ProcessID].Add(sitem.Status.ServiceName);
processServices[sitem.Status.ServiceStatusProcess.ProcessID].Sort();
}
else
{
int oldId = ((ServiceItem)oldItem).Status.ServiceStatusProcess.ProcessID;
if (processServices.ContainsKey(oldId))
{
if (processServices[oldId].Contains(
sitem.Status.ServiceName))
processServices[oldId].Remove(sitem.Status.ServiceName);
}
}
}
public static string GetServiceIconCellHtml(ServiceItem serviceItem, bool useOuterIconUrl)
{
if(serviceItem == null)
throw new ArgumentNullException("service");
string result = string.Format(CultureInfo.InvariantCulture,
IconFormat,
serviceItem.Service.Url,
serviceItem.Service.Copyright,
ServiceSettingsContainer.GetServiceItemType(serviceItem),
useOuterIconUrl ? serviceItem.Service.IconUrl :
WebUI.ResultsWebServer.GetIconUrl(serviceItem.Service.Name));
return result;
}
public void serviceP_DictionaryRemoved_Process(ServiceItem item)
{
if (item.Status.ServiceStatusProcess.ProcessID != 0)
{
if (processServices.ContainsKey(item.Status.ServiceStatusProcess.ProcessID))
{
if (processServices[item.Status.ServiceStatusProcess.ProcessID].Contains(
item.Status.ServiceName))
processServices[item.Status.ServiceStatusProcess.ProcessID].Remove(item.Status.ServiceName);
}
}
}
public static void AddTranslationCell(WebBrowser wBrowser, string parentName, bool isClean, string dataCellHtml, ServiceItem serviceItem, bool useOuterIconUrl)
{
string iconCellHtml = HtmlHelper.GetServiceIconCellHtml(serviceItem, useOuterIconUrl);
AddTranslationCell(wBrowser, parentName, isClean, dataCellHtml, iconCellHtml);
}
public static void DoTranslate(ServiceItem searchEngine, string searchHost, string phrase, LanguagePair languagesPair, string subject, Result result, NetworkSetting networkSetting)
{
string link_f = "http://{0}.{1}/wiki/{2}";
string lang = WikiUtils.ConvertLanguage(languagesPair.To);
string link = string.Format(link_f, lang,
searchHost,
phrase);
result.EditArticleUrl = link;
Result searchResult = searchEngine.Translate(phrase, languagesPair, subject, networkSetting);
if(!searchResult.IsHasData() || searchResult.Translations.Count < 1)
{
result.ResultNotFound = true;
throw new TranslationException("Nothing found");
}
string url = StringParser.Parse("<a href=\"", "\">", searchResult.Translations[0]);
string searched_name = url.Substring(url.LastIndexOf("/") + 1);
if(string.Compare(phrase, searched_name, true) != 0)
{
//check second line
if(searchResult.Translations.Count < 2)
{
result.ResultNotFound = true;
throw new TranslationException("Nothing found");
}
else
{
url = StringParser.Parse("<a href=\"", "\">", searchResult.Translations[1]);
searched_name = url.Substring(url.LastIndexOf("/") + 1);
if(string.Compare(phrase, searched_name, true) != 0)
{
result.ResultNotFound = true;
throw new TranslationException("Nothing found");
}
}
}
link = string.Format(link_f, lang,
searchHost,
searched_name,
searched_name);
result.EditArticleUrl = link;
//http://en.wikipedia.org/w/api.php?action=parse&prop=text&format=xml&page=Ukraine
string query = "http://{0}.{1}/w/api.php?action=parse&prop=text|revid&format=xml&page={2}";
query = string.Format(query, lang,
searchHost,
HttpUtility.UrlEncode(searched_name));
WebRequestHelper helper =
new WebRequestHelper(result, new Uri(query),
networkSetting,
WebRequestContentType.UrlEncodedGet);
string responseFromServer = helper.GetResponse();
if(responseFromServer.IndexOf("<parse revid=\"0\">") >= 0)
{
result.ResultNotFound = true;
throw new TranslationException("Nothing found");
}
string res = StringParser.Parse("<text", "</text>", responseFromServer);
res = StringParser.ExtractRight(">", res);
res = res.Replace("width: 100%", "width: 95%");
res = res.Replace("float:right;", "float: right;margin-right: 0.5em;");
res = "html!<div style='width:{allowed_width}px;overflow:scroll;overflow-y:hidden;overflow-x:auto;'>" + HttpUtility.HtmlDecode(res) + " </div>";
res = res.Replace("<h1>", "");
res = res.Replace("</h1>", "");
res = res.Replace("<h2>", "");
res = res.Replace("</h2>", "");
res = res.Replace("<h3>", "");
res = res.Replace("</h3>", "");
res = res.Replace("<h4>", "");
res = res.Replace("</h4>", "");
res = StringParser.RemoveAll("<span class=\"editsection\">[<a", "</a>]", res);
res = StringParser.RemoveAll("href=\"#", "\"", res);
res = StringParser.RemoveAll("<script type=", "</script>", res);
res = StringParser.RemoveAll("<button onclick=", "</button>", res);
url = string.Format("a href=\"http://{0}.{1}/", lang, searchHost);
res = res.Replace("a href=\"/", url);
url = string.Format("img src=\"http://{0}.{1}/", lang, searchHost);
res = res.Replace("img src=\"/", url);
result.Translations.Add(res);
}
public static void AddTranslationCell(WebBrowser wBrowser, bool isClean, string dataCellHtml, ServiceItem serviceItem)
{
AddTranslationCell(wBrowser, isClean, dataCellHtml, serviceItem, false);
}
private void provider_DictionaryAdded(ServiceItem item)
{
HighlightedListViewItem litem = new HighlightedListViewItem(_highlightingContext, item.RunId > 0 && _runCount > 0)
{
Name = item.Status.ServiceName,
Text = item.Status.ServiceName
};
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem, item.Status.DisplayName));
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem, item.Status.ServiceStatusProcess.ServiceType.ToString()));
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem, item.Status.ServiceStatusProcess.CurrentState.ToString()));
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem, item.Config.StartType.ToString()));
litem.SubItems.Add(new ListViewItem.ListViewSubItem(litem,
item.Status.ServiceStatusProcess.ProcessID == 0 ? string.Empty :
item.Status.ServiceStatusProcess.ProcessID.ToString()));
if ((item.Status.ServiceStatusProcess.ServiceType & ServiceType.InteractiveProcess) != 0)
litem.ImageKey = "Interactive";
else if (item.Status.ServiceStatusProcess.ServiceType == ServiceType.Win32OwnProcess ||
item.Status.ServiceStatusProcess.ServiceType == ServiceType.Win32ShareProcess)
litem.ImageKey = "Win32";
else if (item.Status.ServiceStatusProcess.ServiceType == ServiceType.FileSystemDriver)
litem.ImageKey = "FS";
else
litem.ImageKey = "Driver";
lock (_needsAdd)
_needsAdd.Add(litem);
}
public static string GetServiceItemType(ServiceItem serviceItem)
{
string result;
if(serviceItem is Translator)
{
result = LangPack.TranslateString("Translator");
}
else if(serviceItem is AntonymsDictionary)
{
result = LangPack.TranslateString("Dictionary of antonyms");
}
else if(serviceItem is SynonymsDictionary)
{
result = LangPack.TranslateString("Dictionary of synonyms");
}
else if(serviceItem is PhraseologicalDictionary)
{
result = LangPack.TranslateString("Phraseological dictionary");
}
else if(serviceItem is Encyclopedia)
{
result = LangPack.TranslateString("Encyclopedia");
}
else if(serviceItem is MonolingualSearchEngine || serviceItem is BilingualSearchEngine)
{
result = LangPack.TranslateString("Search Engine");
}
else if(serviceItem is MonolingualDictionary)
{
result = LangPack.TranslateString("Monolingual dictionary");
}
else if(serviceItem is BilingualPhrasesDictionary)
{
result = LangPack.TranslateString("Bilingual phrases dictionary");
}
else if(serviceItem is BilingualSentensesDictionary)
{
result = LangPack.TranslateString("Bilingual sentenses dictionary");
}
else
{
result = LangPack.TranslateString("Bilingual dictionary");
}
return result;
}
