/// <summary>
/// Get the absolute path to the language resources file
/// </summary>
/// <returns>Path</returns>
protected virtual string GetLanguageFile()
{
var languageCode = GetSetting("LANG");
var languageFile = $"{SmiRoxyFilemanDefaults.LanguageDirectory}/{languageCode}.json";
if (!_fileProvider.FileExists(GetFullPath(languageFile)))
{
languageFile = $"{SmiRoxyFilemanDefaults.LanguageDirectory}/en.json";
}
return(GetFullPath(languageFile));
}
/// <summary>
/// Get system names of installed plugins from obsolete file
/// </summary>
/// <returns>List of plugin system names</returns>
protected virtual IList <string> GetObsoleteInstalledPluginNames()
{
//check whether file exists
var filePath = _fileProvider.MapPath(SmiPluginDefaults.InstalledPluginsFilePath);
if (!_fileProvider.FileExists(filePath))
{
//if not, try to parse the file that was used in previous SmiMarketplace versions
filePath = _fileProvider.MapPath(SmiPluginDefaults.ObsoleteInstalledPluginsFilePath);
if (!_fileProvider.FileExists(filePath))
{
return(new List <string>());
}
//get plugin system names from the old txt file
var pluginSystemNames = new List <string>();
using (var reader = new StringReader(_fileProvider.ReadAllText(filePath, Encoding.UTF8)))
{
string pluginName;
while ((pluginName = reader.ReadLine()) != null)
{
if (!string.IsNullOrWhiteSpace(pluginName))
{
pluginSystemNames.Add(pluginName.Trim());
}
}
}
//and delete the old one
_fileProvider.DeleteFile(filePath);
return(pluginSystemNames);
}
var text = _fileProvider.ReadAllText(filePath, Encoding.UTF8);
if (string.IsNullOrEmpty(text))
{
return(new List <string>());
}
//delete the old file
_fileProvider.DeleteFile(filePath);
//get plugin system names from the JSON file
return(JsonConvert.DeserializeObject <IList <string> >(text));
}
/// <summary>
/// Execute commands from a file with SQL script against the context database
/// </summary>
/// <param name="fileProvider">File provider</param>
/// <param name="filePath">Path to the file</param>
protected void ExecuteSqlScriptFromFile(ISmiFileProvider fileProvider, string filePath)
{
filePath = fileProvider.MapPath(filePath);
if (!fileProvider.FileExists(filePath))
{
return;
}
ExecuteSqlScript(fileProvider.ReadAllText(filePath, Encoding.Default));
}
/// <summary>
/// Sends an email
/// </summary>
/// <param name="emailAccount">Email account to use</param>
/// <param name="subject">Subject</param>
/// <param name="body">Body</param>
/// <param name="fromAddress">From address</param>
/// <param name="fromName">From display name</param>
/// <param name="toAddress">To address</param>
/// <param name="toName">To display name</param>
/// <param name="replyTo">ReplyTo address</param>
/// <param name="replyToName">ReplyTo display name</param>
/// <param name="bcc">BCC addresses list</param>
/// <param name="cc">CC addresses list</param>
/// <param name="attachmentFilePath">Attachment file path</param>
/// <param name="attachmentFileName">Attachment file name. If specified, then this file name will be sent to a recipient. Otherwise, "AttachmentFilePath" name will be used.</param>
/// <param name="attachedDownloadId">Attachment download ID (another attachment)</param>
/// <param name="headers">Headers</param>
public virtual void SendEmail(EmailAccount emailAccount, string subject, string body,
string fromAddress, string fromName, string toAddress, string toName,
string replyTo = null, string replyToName = null,
IEnumerable <string> bcc = null, IEnumerable <string> cc = null,
string attachmentFilePath = null, string attachmentFileName = null,
int attachedDownloadId = 0, IDictionary <string, string> headers = null)
{
var message = new MimeMessage();
message.From.Add(new MailboxAddress(fromName, fromAddress));
message.To.Add(new MailboxAddress(toName, toAddress));
if (!string.IsNullOrEmpty(replyTo))
{
message.ReplyTo.Add(new MailboxAddress(replyToName, replyTo));
}
//BCC
if (bcc != null)
{
foreach (var address in bcc.Where(bccValue => !string.IsNullOrWhiteSpace(bccValue)))
{
message.Bcc.Add(new MailboxAddress(address.Trim()));
}
}
//CC
if (cc != null)
{
foreach (var address in cc.Where(ccValue => !string.IsNullOrWhiteSpace(ccValue)))
{
message.Cc.Add(new MailboxAddress(address.Trim()));
}
}
//content
message.Subject = subject;
//headers
if (headers != null)
{
foreach (var header in headers)
{
message.Headers.Add(header.Key, header.Value);
}
}
var multipart = new Multipart("mixed")
{
new TextPart(TextFormat.Html)
{
Text = body
}
};
//create the file attachment for this e-mail message
if (!string.IsNullOrEmpty(attachmentFilePath) && _fileProvider.FileExists(attachmentFilePath))
{
multipart.Add(CreateMimeAttachment(attachmentFilePath, attachmentFileName));
}
//another attachment?
if (attachedDownloadId > 0)
{
var download = _downloadService.GetDownloadById(attachedDownloadId);
//we do not support URLs as attachments
if (!download?.UseDownloadUrl ?? false)
{
multipart.Add(CreateMimeAttachment(download));
}
}
message.Body = multipart;
//send email
using var smtpClient = _smtpBuilder.Build(emailAccount);
smtpClient.Send(message);
smtpClient.Disconnect(true);
}
private void Initialize(string userAgentStringsPath, string crawlerOnlyUserAgentStringsPath)
{
List <XElement> crawlerItems = null;
var needSaveCrawlerOnly = false;
if (!string.IsNullOrEmpty(crawlerOnlyUserAgentStringsPath) && _fileProvider.FileExists(crawlerOnlyUserAgentStringsPath))
{
//try to load crawler list from crawlers only file
using var sr = new StreamReader(crawlerOnlyUserAgentStringsPath);
crawlerItems = XDocument.Load(sr).Root?.Elements("browscapitem").ToList();
}
if (crawlerItems == null || !crawlerItems.Any())
{
//try to load crawler list from full user agents file
using var sr = new StreamReader(userAgentStringsPath);
crawlerItems = XDocument.Load(sr).Root?.Element("browsercapitems")?.Elements("browscapitem")
//only crawlers
.Where(IsBrowscapItemIsCrawler).ToList();
needSaveCrawlerOnly = true;
}
if (crawlerItems == null || !crawlerItems.Any())
{
throw new Exception("Incorrect file format");
}
var crawlerRegexpPattern = string.Join("|", crawlerItems
//get only user agent names
.Select(e => e.Attribute("name"))
.Where(e => !string.IsNullOrEmpty(e?.Value))
.Select(e => e.Value)
.Select(ToRegexp));
_crawlerUserAgentsRegexp = new Regex(crawlerRegexpPattern);
if ((string.IsNullOrEmpty(crawlerOnlyUserAgentStringsPath) || _fileProvider.FileExists(crawlerOnlyUserAgentStringsPath)) && !needSaveCrawlerOnly)
{
return;
}
//try to write crawlers file
using var sw = new StreamWriter(crawlerOnlyUserAgentStringsPath);
var root = new XElement("browsercapitems");
foreach (var crawler in crawlerItems)
{
foreach (var element in crawler.Elements().ToList())
{
if ((element.Attribute("name")?.Value.ToLower() ?? string.Empty) == "crawler")
{
continue;
}
element.Remove();
}
root.Add(crawler);
}
root.Save(sw);
}
/// <summary>
/// Get a value indicating whether some file (thumb) already exists
/// </summary>
/// <param name="thumbFilePath">Thumb file path</param>
/// <param name="thumbFileName">Thumb file name</param>
/// <returns>Result</returns>
protected virtual bool GeneratedThumbExists(string thumbFilePath, string thumbFileName)
{
return(_fileProvider.FileExists(thumbFilePath));
}
/// <summary>
/// Load data settings
/// </summary>
/// <param name="filePath">File path; pass null to use the default settings file</param>
/// <param name="reloadSettings">Whether to reload data, if they already loaded</param>
/// <param name="fileProvider">File provider</param>
/// <returns>Data settings</returns>
public static DataSettings LoadSettings(string filePath = null, bool reloadSettings = false, ISmiFileProvider fileProvider = null)
{
if (!reloadSettings && Singleton <DataSettings> .Instance != null)
{
return(Singleton <DataSettings> .Instance);
}
fileProvider ??= CommonHelper.DefaultFileProvider;
filePath ??= fileProvider.MapPath(SmiDataSettingsDefaults.FilePath);
//check whether file exists
if (!fileProvider.FileExists(filePath))
{
//if not, try to parse the file that was used in previous SmiMarketplace versions
filePath = fileProvider.MapPath(SmiDataSettingsDefaults.ObsoleteFilePath);
if (!fileProvider.FileExists(filePath))
{
return(new DataSettings());
}
//get data settings from the old txt file
var dataSettings = new DataSettings();
using (var reader = new StringReader(fileProvider.ReadAllText(filePath, Encoding.UTF8)))
{
string settingsLine;
while ((settingsLine = reader.ReadLine()) != null)
{
var separatorIndex = settingsLine.IndexOf(':');
if (separatorIndex == -1)
{
continue;
}
var key = settingsLine.Substring(0, separatorIndex).Trim();
var value = settingsLine.Substring(separatorIndex + 1).Trim();
switch (key)
{
case "DataProvider":
dataSettings.DataProvider = Enum.TryParse(value, true, out DataProviderType providerType) ? providerType : DataProviderType.Unknown;
continue;
case "DataConnectionString":
dataSettings.ConnectionString = value;
continue;
default:
dataSettings.RawDataSettings.Add(key, value);
continue;
}
}
}
//save data settings to the new file
SaveSettings(dataSettings, fileProvider);
//and delete the old one
fileProvider.DeleteFile(filePath);
Singleton <DataSettings> .Instance = dataSettings;
return(Singleton <DataSettings> .Instance);
}
var text = fileProvider.ReadAllText(filePath, Encoding.UTF8);
if (string.IsNullOrEmpty(text))
{
return(new DataSettings());
}
//get data settings from the JSON file
Singleton <DataSettings> .Instance = JsonConvert.DeserializeObject <DataSettings>(text);
return(Singleton <DataSettings> .Instance);
}
