/// <summary>
/// Конструктор конфигурации
/// </summary>
/// <param name="name">Наименование</param>
/// <param name="tasks">Список задач</param>
/// <param name="parameters">Список параметров</param>
public Configuration(string name, List <ITask> tasks, ParameterProvider parameters, string description)
{
_name = name;
_tasks = tasks;
_parameters = parameters;
_description = description;
}
public DatabaseOperations(
SPMiddlewareOptions sPMiddlewareOptions,
SwaggerFromSPOptions options,
SqlHelper sqlHelper,
ILogger <DatabaseOperations> logger,
DbConnection dbConnection,
ParameterProvider parametersProvider,
SerializerResolver serializerResolver,
NamingMappingHandler namingMappingHandler,
CodeConvention codeConvention,
ConfigProvider configProvider,
IWebHostEnvironment hostingEnvironment)
{
this.codeConvention = codeConvention;
this.hostingEnvironment = hostingEnvironment;
this.sPMiddlewareOptions = sPMiddlewareOptions;
this.options = options;
this.sqlHelper = sqlHelper;
this.logger = logger;
this.serializerResolver = serializerResolver;
this.dbConnection = dbConnection;
this.parametersProvider = parametersProvider;
this.namingMappingHandler = namingMappingHandler;
entities = configProvider.Entities;
}
/// <summary>
/// Выполнение задачи
/// </summary>
/// <param name="parameters">Провайдер параметров</param>
public void Run(ParameterProvider parameters)
{
if (_timeout > 0)
{
System.Threading.Thread.Sleep(_timeout);
}
}
/// <summary>
/// Выполнение задачи
/// </summary>
/// <param name="parameters">Провайдер параметров</param>
public void Run(ParameterProvider parameters)
{
if (!string.IsNullOrEmpty(_value))
{
parameters.AddParameter(_key, parameters.Parse(_value).First());
}
if (!string.IsNullOrEmpty(_filePath))
{
var filePath = parameters.Parse(_filePath).First();
if (File.Exists(filePath))
{
if (_takeLines == 0)
{
_value = string.Join("\n", File.ReadAllLines(filePath).Skip(_skipLines));
}
else
{
_value = string.Join("\n", File.ReadAllLines(filePath).Skip(_skipLines).Take(_takeLines));
}
parameters.AddParameter(_key, _value);
}
else
{
Application.Log(LogLevel.Error, string.Format("File {0} not found.", filePath));
}
}
}
/// <summary>
/// Team Site All reports
/// </summary>
/// <param name="userAlias"></param>
/// <param name="teamSiteGuid"></param>
/// <param name="isAdmin"></param>
/// <param name="sortField"></param>
/// <param name="sortOrder"></param>
/// <returns></returns>
public IEnumerable <AppReport> GetAllReportsOfTeamSite(string userAlias, string teamSiteGuid, bool isAdmin,
SortField sortField, SortOrder sortOrder)
{
TileServices tService = new TileServices(_tileRepository, _teamRepository, _reportRepository, null, null, null, null);
int teamId = _teamRepository.GetFiltered(_ => _.TeamGuid == new Guid(teamSiteGuid)).FirstOrDefault().Id;
ParameterProvider pp = new ParameterProvider();
pp.AddParameter(ContextVariable.CurrentTeamSiteGuid.ToString(), new Guid(teamSiteGuid));
//if (userAlias != "")
//{
//pp.AddParameter(ContextVariable.CurrentUser.ToString(), userAlias);
//}
pp.AddParameter(ContextVariable.TeamSiteGuidUnderControl.ToString(), new List <Guid> {
new Guid(teamSiteGuid)
});
int allreportsTileId = _tileRepository.GetAllReportsTileId(teamId);
return(_reportRepository.
GetReportsByExpression(
tService.GetTeamSite_AllReportsTile()
.GetCombinedLogic(isAdmin, allreportsTileId)
.GetExpression(pp)).ToArray()
.Select(_ => _.ToAppReport()));
}
public void Run(ParameterProvider parameters)
{
if (!File.Exists(_regularPath))
{
throw new ArgumentNullException("Отсутствует файл с регулярными выражениями");
}
//Получим регулярки
string[] regulars = File.ReadAllLines(_regularPath);
//Откроем файл на редактирование
StreamWriter destinationFile = new StreamWriter(_destination);
using (StreamReader sourceFile = new StreamReader(_source))
{
string logFileContent;
while (sourceFile.Peek() >= 0)
{
logFileContent = sourceFile.ReadLine();
foreach (var regular in regulars)
{
var regex = new Regex(regular);
logFileContent = regex.Replace(logFileContent, new MatchEvaluator(ReplaceEvaluator));
}
destinationFile.WriteLine(logFileContent);
}
}
destinationFile.Close();
}
/// <summary>
/// Выполнение задачи
/// </summary>
/// <param name="parameters">Провайдер параметров</param>
public void Run(ParameterProvider paramProvider)
{
// ZipFile довольно глупый и если будет создавать в архив в тойже директории которую архивирует, он свалится.
// Поэтому сперва моздаем временный файл
var tempFile = System.IO.Path.Combine(System.IO.Path.GetTempPath(), System.IO.Path.GetRandomFileName());
var fromPath = paramProvider.Parse(_from).First();
ZipFile.CreateFromDirectory(fromPath, tempFile);
if (_deleteAfterArchive)
{
var directory = System.IO.Path.GetDirectoryName(fromPath);
var wildcard = System.IO.Path.GetFileName(fromPath);
foreach (var fn in Directory.GetFiles(directory, wildcard, SearchOption.TopDirectoryOnly))
{
System.IO.File.Delete(fn);
}
}
var destination = paramProvider.Parse(_to).First();
if (File.Exists(destination))
{
File.Delete(destination);
}
File.Move(tempFile, paramProvider.Parse(_to).First());
}
/// <summary>
/// Выполнение задачи
/// </summary>
/// <param name="parameters">Провайдер параметров</param>
public void Run(ParameterProvider parameters)
{
var enc = String.IsNullOrEmpty(_fileEncoding) ? System.Text.Encoding.UTF8 : System.Text.Encoding.GetEncoding(_fileEncoding);
_filePath = parameters.Parse(_filePath).First();
File.WriteAllText(_filePath, parameters.GetParameters()[_key], enc);
}
public IQueryable <Report> GetReportByLogic(Logic logic, ParameterProvider parameterProvider)
{
Expression <Func <Report, Boolean> > filterExpression = logic.GetExpression(parameterProvider);
IQueryable <Report> query = GetReportsByExpression(filterExpression);
return(query);
}
public void GetParameter_NoParametersLoaded_ReturnsException()
{
//Arrange
ParameterProvider parameterProvider = new ParameterProvider(parameterSource);
//Assert
Assert.Throws <Exception>(() => parameterProvider.GetParameter(3));
}
public void LoadCSVParameter_EmptyFilePath_ReturnsException()
{
//Arrange
ParameterProvider parameterProvider = new ParameterProvider(parameterSource);
//Assert
Assert.Throws <Exception>(() => parameterProvider.LoadParameters(""));
}
public int ComputeStatistic()
{
StoredProcedure storedProcedure = new StoredProcedure();
storedProcedure.Name = My.Resources.CreateInsertSPList()[TableList.DiaryDate].ToString();
storedProcedure.ParameterValueCollection = ParameterProvider.GetParameterListForInsertDairyDateItem(DateItem);
return(dairyController.Execute(storedProcedure));
}
public List <DairyListItem> Select()
{
StoredProcedure storedProcedure = new StoredProcedure();
storedProcedure.Name = My.Resources.CreateSelectByNameSPList()[TableList.DiaryListItem].ToString();
storedProcedure.ParameterValueCollection = ParameterProvider.GetParameterListForInsertDairyDateItem(DateItem);
return(dairyItemController.ExecuteSync(storedProcedure).ToList());
}
public static void GroupSetup()
{
// Print debug information to the console to aid with parameter debugging.
ParameterProvider.PrintDebugInformation(parameterProvider);
// Create the test state tracker to track the group's run state against SentryOne Test.
testStateTracker = new TestStateTracker(typeof(CostofgoodsSold), Resources.TestManifest_CostofgoodsSold_b701adc3f42040098e08e425a8b80dbc, TestAssemblyInformation.AssemblyTestCount, TestAssemblyInformation.SuiteTestCounts, parameterProvider);
// Inform the server that the test group has started.
testStateTracker.RegisterGroupStarted();
}
public void GetParameterSets_ReturnsCorrectNumberOfSets(int numberOfSets)
{
var paramProvider = new ParameterProvider();
var builders = new IParameterValueBuilder[] { new FakeParameterValueBuilder("ParamOne", 1) };
var sets = paramProvider.GetParameterSets(builders, numberOfSets);
Assert.AreEqual(numberOfSets, sets.Count());
}
public void Update()
{
StoredProcedure storedProcedure = new StoredProcedure();
storedProcedure.Name = My.Resources.CreateUpdateSPList()[TableList.DiaryListItem].ToString();
storedProcedure.ParameterValueCollection = ParameterProvider.GetParameterListForSelectDairyListItem(ListItem);
dairyItemController.ExecuteSync(storedProcedure);
}
/// <summary>
/// Создание временной конфигурации для быстрого анализа.
/// </summary>
/// <param name="template">шаблон</param>
/// <param name="product">приложение</param>
/// <returns></returns>
internal static Configuration CreateInstant(IISApplication product)
{
Template template = null;
string productCode = null;
foreach (var config in Directory.GetFiles(product.Path, "*.config"))
{
var appConfig = XDocument.Load(config);
productCode = appConfig.Root.Element("NpoComputer.Product")?.Element("Code")?.Value;
if (string.IsNullOrEmpty(productCode))
{
continue;
}
template = TemplateManager.GetByProductCode(productCode, FilterMode.InstantOnly);
if (template != null)
{
break;
}
}
if (template == null)
{
throw new FileNotFoundException("Не найдено подходящих шаблонов для данного приложения.");
}
Core.Application.Log(LogLevel.Informational, "Загрузка параметров для сайта \"{0}\"", product);
var xml = XDocument.Load(template.ConfigurationPath);
var p = xml.XPathSelectElements(@"Configuration/Parameters/Parameter");
var parameters = new ParameterProvider(p.ToDictionary(k => k.Attribute("name").Value, v => v.Attribute("value").Value));
parameters.AddParameter("ConfigurationPath", Path.Combine("Templates", template.Name));
parameters.AddParameter("ReportsPath", Path.Combine(Core.Application.WorkingFolder, "Reports"));
parameters.AddParameter("Title", product.ToString());
parameters.AddParameter("SiteLogFile", product.IISLogPath);
parameters.AddParameter("ApplicationPath", product.Path);
if (productCode.Contains("NOMAD")) //TODO: Убрать костыль
{
var appPath = product.Path;
var logSettings = XDocument.Load(Path.Combine(appPath, "LogSettings.config"));
var path = ((IEnumerable)logSettings.XPathEvaluate("/*[name()='nlog']/*[name()='variable' and @name='logs-path']/@value")).Cast <XAttribute>().FirstOrDefault()?.Value;
if (path != null && path.Contains("basedir"))
{
path = Path.Combine(appPath, @"App_Data\Logs\");
}
parameters.AddParameter("ApplicationLogsPath", path);
//TODO: Получать путь
parameters.AddParameter("ClientsLogPath", Path.Combine(appPath, @"\App_Data\ClientLogs\"));
}
var taskNodes = xml.XPathSelectElements(@"Configuration/Tasks/Task");
var tasks = taskNodes.Select(t => Tasks.TaskFactory.Create(t)).ToList();
return(new Configuration(template.Name, tasks, parameters, null));
}
/// <summary>
/// Выполнение задачи
/// </summary>
/// <param name="parameters">Провайдер параметров</param>
public void Run(ParameterProvider parameters)
{
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.WindowStyle = ProcessWindowStyle.Hidden;
startInfo.FileName = "cmd.exe";
startInfo.Arguments = "/c " + parameters.Parse(_arguments).First() + " exit ";
Process.Start(startInfo).WaitForExit();
Application.Log(LogLevel.Informational, "{0} {1}", startInfo.FileName, startInfo.Arguments);
}
public void Insert()
{
ListItem.DateID = dairyController.Execute(
ParameterProvider.GetParameterListForInsertDairyDateItem(DateItem),
My.Resources.CreateInsertSPList()[TableList.DiaryDate].ToString());
dairyItemController.ExecuteAsync(
ParameterProvider.GetParameterListForInsertDairyListItem(ListItem),
My.Resources.CreateInsertSPList()[TableList.DiaryListItem].ToString());
}
/// <summary>
/// Выполнение задачи
/// </summary>
/// <param name="parameters">Провайдер параметров</param>
public void Run(ParameterProvider parameters)
{
using (SmtpClient SmtpServer = new SmtpClient(parameters.Parse(_server).First(), int.Parse(parameters.Parse(_port).First())))
{
using (MailMessage mail = new MailMessage())
{
mail.From = new MailAddress(parameters.Parse(_from).First());
foreach (var mailAddress in parameters.Parse(_to).First().Split(';'))
{
if (!string.IsNullOrWhiteSpace(mailAddress))
{
mail.To.Add(mailAddress);
}
}
if (_cc != null)
{
var cc = parameters.Parse(_cc).First();
if (!string.IsNullOrWhiteSpace(cc))
{
foreach (var mailAddress in cc.Split(';'))
{
if (!string.IsNullOrWhiteSpace(mailAddress))
{
mail.CC.Add(mailAddress);
}
}
}
}
mail.Subject = parameters.Parse(_subject).First();
mail.Body = parameters.Parse(_body).First();
mail.IsBodyHtml = true;
// Добавление вложений
if (!string.IsNullOrEmpty(_attachment))
{
System.Net.Mail.Attachment attachment;
attachment = new System.Net.Mail.Attachment(parameters.Parse(_attachment).First());
mail.Attachments.Add(attachment);
}
SmtpServer.EnableSsl = Boolean.Parse(parameters.Parse(_useSSL).First());
SmtpServer.UseDefaultCredentials = false;
SmtpServer.DeliveryMethod = SmtpDeliveryMethod.Network;
if (_server.ToLower(CultureInfo.InvariantCulture).Contains("gmail.com"))
{
SmtpServer.TargetName = "STARTTLS/smtp.gmail.com";
}
SmtpServer.Credentials = new System.Net.NetworkCredential(parameters.Parse(_user).First(), parameters.Parse(_password).First());
SmtpServer.Send(mail);
}
}
}
public void LoadCSVParameter_ParameterSource_SetMaxRows()
{
//Arrange
ParameterProvider parameterProvider = new ParameterProvider(parameterSource);
//Act
parameterProvider.LoadParameters(filePath);
//Assert
Assert.True(parameterSource.MaxRows > 1);
}
public void LoadCSVParameter_ParameterSource_ReturnsCSV()
{
//Arrange
ParameterProvider parameterProvider = new ParameterProvider(parameterSource);
//Act
string parameters = parameterProvider.LoadParameters(filePath);
//Assert
Assert.True(IsFloat(parameters, 1));
}
/// <summary>
/// Выполнение задачи
/// </summary>
/// <param name="parameters">Провайдер параметров</param>
public void Run(ParameterProvider paramProvider)
{
//TODO: Проверки.
var from = paramProvider.Parse(_from).First();
var to = paramProvider.Parse(_to).First();
ZipFile.ExtractToDirectory(from, to);
if (_deleteAfterExtract)
{
File.Delete(from);
}
}
public AbstractRuntimeDeserializer(TypeToken typeToken, TypeTokenType typeTokenType) : base()
{
_iteratorProvider = new ParameterProvider(typeof(int));
MemberProvider = typeTokenType switch
{
TypeTokenType.Field => t => t.Fields,
TypeTokenType.Property => t => t.Properties,
_ => throw new InvalidOperationException(),
};
Members = MemberProvider(typeToken);
}
/// <summary>
/// Выполнение задачи
/// </summary>
/// <param name="parameters">Провайдер параметров</param>
public void Run(ParameterProvider parameters)
{
var types = new TypeRegistry();
types.RegisterDefaultTypes();
types.RegisterType("CultureInfo", typeof(CultureInfo));
types.RegisterSymbol("fromDate", parameters._fromDate);
types.RegisterSymbol("toDate", parameters._toDate);
var expression = new CompiledExpression(parameters.Parse(_expression).First());
expression.TypeRegistry = types;
parameters.AddParameter(parameters.Parse(_outputParam).First(), expression.Eval().ToString());
}
public Func <T, string> Compile <T>(string formatString, IFormatProvider formatProvider, NullCheckMode nullCheckMode)
{
// Guard anyway, since we may be used by things that don't understand nullable reference types
if (formatString == null)
{
throw new ArgumentNullException(nameof(formatString));
}
if (formatProvider == null)
{
throw new ArgumentNullException(nameof(formatProvider));
}
// Parse the string to a set of segments
IEnumerable <ISegment> segments = ParseFormatString(formatString);
// Create necessary constant expressions and parameterhelper
ParameterExpression parameter = Expression.Parameter(typeof(T));
Expression formatProviderExpression = Expression.Constant(formatProvider);
ParameterProvider <T> parameterProvider = new ParameterProvider <T>(parameter, BINDING_FLAGS, nullCheckMode);
// Compile segments to constituent expressions.
// Materialize the IEnumerable to a list in order to avoid recalculating the expressions while deciding which concatenation layout to use.
IEnumerable <Expression> segmentExpressions = segments.Select(s => s.ToExpression <T>(parameterProvider, formatProviderExpression)).ToList();
// Select the best method of forming the string
// TODO May be faster to nest concat operations up until a certain point before resorting to allocating an array object in the process. Perhaps a user preference?
Expression formatExpression;
if (segments.Count() == 1)
{
formatExpression = CompileToSingleton <T>(segmentExpressions.First());
}
else if (segments.Count() <= 4)
{
formatExpression = CompileToSingleConcat <T>(segmentExpressions);
}
else
{
formatExpression = CompileToArrayConcat <T>(segmentExpressions);
}
// Construct a lambda function from the compiled expression
return(Expression.Lambda <Func <T, string> >(
formatExpression,
"FastStringFormatAutogenerated",
new ParameterExpression[] { parameter }
).Compile());
}
public void Initialize(ParameterProvider provider = null)
{
setting = new Setting();
setting.Initialize(provider);
log = LogManager.GetCurrentClassLogger();
Sync();
JobManager.AddJob(() => Sync(), s =>
{
s.ToRunEvery(1).Days().At(setting.Hours, setting.Minutes);
});
}
/// <summary>
/// Временная конфигурация по шаблону.
/// </summary>
/// <param name="template">Шаблон</param>
/// <returns></returns>
internal static Configuration CreateInstant(Template template)
{
Core.Application.Log(LogLevel.Informational, "Загрузка параметров для \"{0}\"", template.Name);
var xml = XDocument.Load(template.ConfigurationPath);
var p = xml.XPathSelectElements(@"Configuration/Parameters/Parameter");
var parameters = new ParameterProvider(p.ToDictionary(k => k.Attribute("name").Value, v => v.Attribute("value").Value));
parameters.AddParameter("ConfigurationPath", Path.Combine("Templates", template.Name));
parameters.AddParameter("ReportsPath", Path.Combine(Core.Application.WorkingFolder, "Reports"));
parameters.AddParameter("Title", template.Name);
var taskNodes = xml.XPathSelectElements(@"Configuration/Tasks/Task");
var tasks = taskNodes.Select(t => Tasks.TaskFactory.Create(t)).ToList();
return(new Configuration(template.Name, tasks, parameters, null));
}
public void Insert()
{
StoredProcedure firstStoredProcedure = new StoredProcedure();
firstStoredProcedure.Name = My.Resources.CreateInsertSPList()[TableList.DiaryDate].ToString();
firstStoredProcedure.ParameterValueCollection = ParameterProvider.GetParameterListForInsertDairyDateItem(DateItem);
ListItem.DateID = dairyController.Execute(firstStoredProcedure);
StoredProcedure secondStoredProcedure = new StoredProcedure();
secondStoredProcedure.Name = My.Resources.CreateInsertSPList()[TableList.DiaryListItem].ToString();
secondStoredProcedure.ParameterValueCollection = ParameterProvider.GetParameterListForInsertDairyListItem(ListItem);
dairyItemController.ExecuteAsync(secondStoredProcedure);
}
public ICollection <Statistics> GetTeamSiteReportsStatistics(Int32 tileId, String userAlias, String teamSiteGuid, Boolean isCurrentSiteAdmin)
{
bool hasAdminSite = isCurrentSiteAdmin;
TileServices tService = new TileServices(_tileRepository, _teamRepository, _reportRepository, _userRepository, _tagRepository, _categoryRepository, _tileQueryRepository);
AppTile at = tService.GetTileById(tileId);
ParameterProvider pp = new ParameterProvider();
//if (userAlias != "")
//{
//pp.AddParameter(ContextVariable.CurrentUser.ToString(), userAlias);
//}
pp.AddParameter(ContextVariable.CurrentTeamSiteGuid.ToString(), new Guid(teamSiteGuid));
//pp.AddParameter(ContextVariable.CurrentUserGroup.ToString(), appUserGroupList);
//if (hasAdminSite)
//{
pp.AddParameter(ContextVariable.TeamSiteGuidUnderControl.ToString(), new List <Guid>()
{
new Guid(teamSiteGuid)
});
//}
Logic logic = at.GetCombinedLogic(hasAdminSite, tileId).And((new TeamSiteGUID()).Equal(Guid.Parse(teamSiteGuid)));
var reports = _reportRepository.GetReportByLogic(logic, pp).ToArray().Select(_ => _.ToAppReport()).ToList();
foreach (var report in reports)
{
foreach (var cat in report.Categories)
{
if (cat.ParentId != null)
{
cat.ParentCategory = _categoryRepository.Get(cat.ParentId.GetValueOrDefault()).ToAppCategory();
//cat.Reports.Add(report);
}
}
}
return(GetStatistics(reports));
}
/// <summary>
/// Return a pointer to the unmanaged version of this callback.
/// </summary>
/// <param name="callback">The callback.</param>
/// <returns>A pointer to a shadow c++ callback</returns>
public static IntPtr ToIntPtr(ParameterProvider callback)
{
return ToCallbackPtr<ParameterProvider>(callback);
}
