public void MemoGen()
{
MemoReport memo = new MemoReport();
// memo.CreateDocument("D:\\Testing\\",null,null);
ModelMemoReport memoReport = new ModelMemoReport()
{
SelectParameterDocument = new SelectParameterDocument()
{
IdUser = 33, NameDocument = "RR", NumberDocument = 4, TabelNumber = "7751-00-099", TypeDocument = 1
}
};
SelectSql select = new SelectSql();
SelectImns selectFrames = new SelectImns();
SqlConnectionType sql = new SqlConnectionType();
XmlReadOrWrite xml = new XmlReadOrWrite();
select.SelectMemoReport(ref memoReport);
var commandOrders = string.Format(selectFrames.LastOrder, memoReport.UserDepartment.SmallTabelNumber);
var userOrder = sql.XmlString("Data Source=i7751-app020;Initial Catalog=imns51;Integrated Security=True;MultipleActiveResultSets=True", commandOrders);
if (userOrder != null)
{
userOrder = string.Concat("<Orders>", userOrder, "</Orders>");
memoReport.UserDepartment.Orders = ((Orders)xml.ReadXmlText(userOrder, typeof(Orders)));
}
memo.CreateDocument("D:\\Testing\\", memoReport);
}
/// <summary>
/// Создание процесса Прием КРСБ Наследника Массово
/// </summary>
/// <param name="conectstring">Строка соединения</param>
/// <param name="setting">Настройки</param>
/// <returns></returns>
public string CreateKrsb(string conectstring, FullSetting setting)
{
try
{
var delocreate = new AddKrsb();
var sqlconnect = new SqlConnectionType();
SerializeJson serializeJson = new SerializeJson();
if (setting.DeloPriem.DelaPriem.Count > 0)
{
delocreate.CreateDelo(setting.DeloPriem.DelaPriem);
sqlconnect.StartingProcedure <string, string>(conectstring, ((ServiceWcf)
sqlconnect.SelectFullParametrSqlReader(conectstring,
ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf),
ModelSqlFullService.ParamCommand("19"))).ServiceWcfCommand.Command);
return(serializeJson.JsonLibary((CreateDela)sqlconnect.SelectFullParametrSqlReader <string, string>(conectstring,
((ServiceWcf)
sqlconnect.SelectFullParametrSqlReader(conectstring,
ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf),
ModelSqlFullService.ParamCommand("20"))).ServiceWcfCommand.Command, typeof(CreateDela))));
}
Loggers.Log4NetLogger.Error(new Exception("Нет дел для создания процессов!!!"));
return(null);
}
catch (Exception e)
{
Loggers.Log4NetLogger.Error(e);
return(null);
}
}
/// <summary>
/// Процедуры предпроверки
/// </summary>
/// <param name="connection">Строка соединения</param>
/// <param name="seting">Настройки</param>
/// <returns></returns>
public async Task <string> TaskSqlProcedureSoprovod(string connection, FullSetting seting)
{
var sqlconnect = new SqlConnectionType();
GenerateParametrSql.GenerateParametrSql sql = new GenerateParametrSql.GenerateParametrSql();
Dictionary <string, string> listparametr = new Dictionary <string, string>();
if (seting.ParamPredproverka.N441 != 0)
{
sql.CreateParamert(ref listparametr, seting.ParamPredproverka.GetType(), seting.ParamPredproverka);
}
switch (seting.Id)
{
case 1:
return(await Task.Factory.StartNew(() => sqlconnect.StartingProcedure(connection, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connection, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand("15"))).ServiceWcfCommand.Command, listparametr)));
case 2:
return(await Task.Factory.StartNew(() => sqlconnect.StartingProcedure(connection, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connection, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand("16"))).ServiceWcfCommand.Command, listparametr)));
case 3:
return(await Task.Factory.StartNew(() => sqlconnect.StartingProcedure(connection, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connection, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand("17"))).ServiceWcfCommand.Command, listparametr)));
default:
return(null);
}
}
/// <summary>
/// Данный блок относится к БДК
/// </summary>
/// <param name="conectionstring">Строка соединения</param>
/// <param name="select">Команда Select</param>
/// <returns>Возвращаем модель JSON в виде строки</returns>
public string BdkSqlSelect(string conectionstring, string select)
{
var sqlconnect = new SqlConnectionType();
SerializeJson serializeJson = new SerializeJson();
return(serializeJson.JsonLibary((AnalisBdkFull)sqlconnect.SelectFullParametrSqlReader <string, string>(conectionstring, select, typeof(AnalisBdkFull))));
}
/// <summary>
/// Выгрузка модели телефонного справочника
/// </summary>
/// <param name="logic">Логика выборки</param>
/// <param name="listparametr">Параметры</param>
/// <returns>Возвращает объект для превращения его в схему</returns>
public object GenerateSchemeXsdSql <TKey, TValue>(LogicaSelect logic, Dictionary <TKey, TValue> listparametr = null)
{
var sqlConnect = new SqlConnectionType();
switch (logic.Id)
{
case 10:
TelephoneHelp telephoneHelp = new TelephoneHelp
{
TelephonHeaders =
((TelephoneHelp)sqlConnect.SelectFullParametrSqlReader(ConnectionString, logic.SelectUser,
typeof(TelephoneHelp), ModelSqlFullService.ParamCommand("1"))).TelephonHeaders,
TelephonBody =
((TelephoneHelp)
sqlConnect.SelectFullParametrSqlReader(ConnectionString, logic.SelectUser,
typeof(TelephoneHelp), ModelSqlFullService.ParamCommand("2"))).TelephonBody
};
return(telephoneHelp);
case 12:
Book book = new Book
{
BareCodeBook = new BareCodeBook(),
Organization = ((Book)sqlConnect.SelectFullParametrSqlReader(ConnectionString, logic.SelectUser, typeof(Book), listparametr)).Organization
};
return(book);
default:
return(null);
}
}
public string SqlSelect(string conectionstring, AngularModel command)
{
var sqlconnect = new SqlConnectionType();
SerializeJson serializeJson = new SerializeJson();
switch (command.Id)
{
case 1:
return(serializeJson.JsonLibary((SysNum)sqlconnect.SelectFullParametrSqlReader <string, string>(conectionstring, command.Command, typeof(SysNum))));
case 12:
return(serializeJson.JsonLibary((Mail)sqlconnect.SelectFullParametrSqlReader <string, string>(conectionstring, command.Command, typeof(Mail))));
case 13:
return(serializeJson.JsonLibary((ModelFull)sqlconnect.SelectFullParametrSqlReader <string, string>(conectionstring, command.Command, typeof(ModelFull))));
case 14:
return
(serializeJson.JsonLibary(
(Soprovod)
sqlconnect.SelectFullParametrSqlReader <string, string>(conectionstring, command.Command,
typeof(Soprovod))));
case 21: return(serializeJson.JsonLibary((No)sqlconnect.SelectFullParametrSqlReader <string, string>(conectionstring, command.Command, typeof(No))));
default:
return("Данная комманда не определена!!!");
}
}
public DataSet GetSetFromQuery(SqlConnectionType connectionType, string query, params object[] parameters)
{
using (SqlConnection conn = GetSqlConnection(connectionType))
{
DataSet ds = SqlHelper.ExecuteCachedDataset(conn, CommandType.Text, query, 60, parameters);
return(ds);
}
}
public DataTable GetTableFromQuery(SqlConnectionType connectionType, string query)
{
using (SqlConnection conn = GetSqlConnection(connectionType))
{
DataSet ds = SqlHelper.ExecuteCachedDataset(conn, CommandType.Text, query, 60);
return(ds.Tables[0]);
}
}
public IUnitOfWork BeginUnitOfWork(SqlConnectionType connectiontype, SqlIsolationLevel isolationLevel, string feature)
{
SqlConnection sqlConnection = SqlConnectionContext.GetDBConnection();//Unopened
var isReadonlyConnection = connectiontype == SqlConnectionType.UseReadOnlyDatabase;
var myDbContext = new MyDbContext(sqlConnection, isReadonlyConnection);
return(new EntityUnitOfWork(myDbContext));
}
/// <summary>
/// Возвращает название инспекции по номеру инспекции FullSetting.Inspection.Number
/// </summary>
/// <param name="conectionstring">Строка соединения</param>
/// <param name="N279">Номер инспекции</param>
/// <returns>Название инспекции</returns>
public Insp Inspection(string conectionstring, string N279)
{
var sqlconnect = new SqlConnectionType();
Dictionary <string, string> listparametr = new Dictionary <string, string>();
listparametr.Add("@N279", N279);
return((Insp)sqlconnect.SelectFullParametrSqlReader(conectionstring, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(conectionstring, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand("30"))).ServiceWcfCommand.Command, typeof(Insp), listparametr));
}
/// <summary>
/// Вытаскиваем внутреннею команду с сайта
/// </summary>
/// <param name="setting">Параметры</param>
/// <returns></returns>
private ServiceWcf Service(FullSetting setting)
{
var sqlConnect = new SqlConnectionType();
return
((ServiceWcf)
sqlConnect.SelectFullParametrSqlReader(ConnectionString, ModelSqlFullService.ProcedureSelectParametr,
typeof(ServiceWcf), ModelSqlFullService.ParamCommand(setting.Id.ToString())));
}
/// <summary>
/// Запрос на выгрузку данных в таблицу XLSX по заданной выборки View
/// </summary>
/// <param name="sqlSelect">Sql запрос</param>
/// <param name="nameFile">Наименование файла</param>
/// <param name="nameReport">Наименование отчета</param>
/// <param name="pathSaveReport">Путь сохранения отчета</param>
/// <returns></returns>
public Stream GenerateStreamToSqlViewFile(string sqlSelect, string nameFile, string nameReport, string pathSaveReport)
{
var sqlConnect = new SqlConnectionType();
var xlsx = new ReportExcel();
var tableTelephone = sqlConnect.ReportQbe(ConnectionString, sqlSelect);
xlsx.ReportSave(pathSaveReport, nameFile, nameReport, tableTelephone);
return(xlsx.DownloadFile(Path.Combine(pathSaveReport, $"{nameFile}.xlsx")));
}
public SqlConnection GetSqlConnection(SqlConnectionType connectionType)
{
if (connectionType == SqlConnectionType.ReadWrite)
{
return(GetSqlConnection());
}
return(GetReadOnlySqlConnection());
}
/// <summary>
/// Конструктор выполнения процедуры на сервере
/// </summary>
/// <param name="connectin"></param>
public SelectInventory(string connectin)
{
Connection = connectin;
var sqlconnect = new SqlConnectionType();
Command =
(InventarizationCommandWcfToSql)
sqlconnect.SelectFullParametrSqlReader(Connection, ModelProcedure.ModelProcedure.ProcedureSelect,
typeof(InventarizationCommandWcfToSql), ModelProcedure.ModelProcedure.ParamCommand("1"));
}
/// <summary>
/// Вытягивание выборки на сайт для подставления в нее параметров данных
/// </summary>
/// <param name="conectionstring">Строка соединения</param>
/// <param name="setting">Параметры настройки</param>
/// <returns></returns>
public string ServiceCommand(string conectionstring, FullSetting setting)
{
var sqlconnect = new SqlConnectionType();
SerializeJson serializeJson = new SerializeJson();
return(serializeJson.JsonLibary(
(ServiceWcf)
sqlconnect.SelectFullParametrSqlReader(conectionstring, ModelSqlFullService.ProcedureSelectParametr,
typeof(ServiceWcf), ModelSqlFullService.ParamCommand(setting.ParamService.IdCommand.ToString()))));
}
public T GetIDBySP <T>(SqlConnectionType connectionType, string spName, params object[] parameters)
{
List <T> ids = GetIDsBySP <T>(connectionType, spName, parameters);
if (ids != null && ids.Count > 0)
{
return(ids[0]);
}
return(default(T));
}
/// <summary>
/// Отчет для СТО выгрузка
/// </summary>
/// <param name="pathSaveReport">Путь сохранения</param>
/// <param name="analysisEpo">Выбранный анализ</param>
/// <returns></returns>
private byte[] CreateReportEpo(string pathSaveReport, AnalysisEpoAndInventarka analysisEpo)
{
var xlsx = new ReportExcel();
var sqlConnect = new SqlConnectionType();
var reportAnalysis = sqlConnect.ReportQbe(ConnectionString, analysisEpo.ViewReport);
xlsx.ReportAddListFile(analysisEpo.NameListXlsx, reportAnalysis);
Dispose(true);
xlsx.SaveAsFileXlsx(Path.Combine(pathSaveReport, analysisEpo.NameFileXlsx));
return(xlsx.ReadFileByte(Path.Combine(pathSaveReport, analysisEpo.NameFileXlsx)));
}
public IUnitOfWork BeginUnitOfWork(SqlConnectionType connectiontype, SqlIsolationLevel isolationLevel, string feature)
{
var sqlConnectionUnitOfWork = new SqlConnectionFactoryContext().BeginUnitOfWork(connectiontype, isolationLevel, null);
var entityUnitOfWork = new EntityUnitOfWorkFactory().BeginUnitOfWork(connectiontype, isolationLevel, null);
return(new UnitOfWorkComposite(new List <IUnitOfWork>
{
sqlConnectionUnitOfWork,
entityUnitOfWork
}));
}
/// <summary>
/// Выбор файла для передачи
/// </summary>
/// <param name="path">Путь к файлу</param>
/// <param name="filename">Имя файла</param>
/// <param name="conectionstring">Строка соединения с БД для формирования таблицы</param>
/// <returns></returns>
public async Task <Stream> SelectDonloadsFile(string path, string filename, string conectionstring = null, DataSet dataSet = null)
{
var sqlconnect = new SqlConnectionType();
var xlsx = new ReportExcel();
switch (filename)
{
case "Требования.xlsx":
if (File.Exists(Path.Combine(path, filename)))
{
return
(await Task.Factory.StartNew <Stream>(
() => DonloadFile(Path.Combine(path, filename))));
}
return(null);
case "Бдк.xlsx":
xlsx.ReportSave(path, "Бдк", "Бдк", sqlconnect.ReportQbe(conectionstring, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(conectionstring, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand("6"))).ServiceWcfCommand.Command));
if (File.Exists(Path.Combine(path, filename)))
{
return
(await Task.Factory.StartNew <Stream>(
() => DonloadFile(Path.Combine(path, filename))));
}
xlsx.Dispose();
return(null);
case "Истребование.xlsx":
xlsx.ReportSave(path, "Истребование", "Не доделки по документам", sqlconnect.ReportQbe(conectionstring, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(conectionstring, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand("18"))).ServiceWcfCommand.Command));
if (File.Exists(Path.Combine(path, filename)))
{
return
(await Task.Factory.StartNew <Stream>(
() => DonloadFile(Path.Combine(path, filename))));
}
xlsx.Dispose();
return(null);
case "Камеральный №5.xlsx":
xlsx.ReportSave(path, "Камеральный №5", "Отчет", dataSet);
if (File.Exists(Path.Combine(path, filename)))
{
return
(await Task.Factory.StartNew <Stream>(
() => DonloadFile(Path.Combine(path, filename))));
}
xlsx.Dispose();
return(null);
default:
return(null);
}
}
/// <summary>
/// Шаблон который используем написано кустарно нужно давать Ун шаблона на вход!!!
/// </summary>
/// <param name="conectionstring">Строка соединения</param>
/// <param name="setting">Параметры шаблона</param>
/// <returns></returns>
public Document Template(string conectionstring, FullSetting setting)
{
var sqlconnect = new SqlConnectionType();
Dictionary <string, string> listparametr = new Dictionary <string, string>();
GenerateParametrSql.GenerateParametrSql sql = new GenerateParametrSql.GenerateParametrSql();
if (setting.UseTemplate.IdTemplate != 0)
{
sql.CreateParamert(ref listparametr, setting.UseTemplate.GetType(), setting.UseTemplate);
}
return((Document)sqlconnect.SelectFullParametrSqlReader(conectionstring, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(conectionstring, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand("10"))).ServiceWcfCommand.Command, typeof(Document), listparametr));
}
public void TestOfficialXlsx()
{
ReportCardModel model = new ReportCardModel()
{
SettingParameters = new SettingParameters()
{
TabelNumber = "7751-00-548", Year = 2021, IdDepartment = 8,
Type = new Type()
{
IdType = 1, NameType = "Полный"
},
View = new View()
{
IdView = 0, NameView = "Первичный"
},
Mouth = new Mouth()
{
NumberMouthString = "09", NameMouth = "Сентябрь", NumberMouth = 9
}
}
};
SqlConnectionType sql = new SqlConnectionType();
SelectImns selectFrames = new SelectImns();
XmlReadOrWrite xml = new XmlReadOrWrite();
SelectSql select = new SelectSql();
select.SelectCardModelLeader(ref model);
var command = string.Format(selectFrames.UserReportCard, model.SettingParameters.LeaderD.NameDepartment, $"{model.SettingParameters.Year}-{model.SettingParameters.Mouth.NumberMouthString}-01");
var userReportCard = sql.XmlString("Data Source=i7751-app020;Initial Catalog=imns51;Integrated Security=True;MultipleActiveResultSets=True", command);
userReportCard = string.Concat("<SettingParameters>", userReportCard, "</SettingParameters>");
model.SettingParameters.UsersReportCard = ((SettingParameters)xml.ReadXmlText(userReportCard, typeof(SettingParameters))).UsersReportCard;
foreach (var usersReportCard in model.SettingParameters.UsersReportCard)
{
var commandVacation = string.Format(selectFrames.ItemVacationNew, usersReportCard.Tab_num, $"{model.SettingParameters.Year}", $"{model.SettingParameters.Year}");
var userVacation = sql.XmlString("Data Source=i7751-app020;Initial Catalog=imns51;Integrated Security=True;MultipleActiveResultSets=True", commandVacation);
userVacation = string.Concat("<UsersReportCard>", userVacation, "</UsersReportCard>");
usersReportCard.ItemVacation = ((UsersReportCard)xml.ReadXmlText(userVacation, typeof(UsersReportCard))).ItemVacation;
var commandDisability = string.Format(selectFrames.Disability, usersReportCard.Tab_num, $"{model.SettingParameters.Year}");
var userDisability = sql.XmlString("Data Source=i7751-app020;Initial Catalog=imns51;Integrated Security=True;MultipleActiveResultSets=True", commandDisability);
userDisability = string.Concat("<UsersReportCard>", userDisability, "</UsersReportCard>");
usersReportCard.Disability = ((UsersReportCard)xml.ReadXmlText(userDisability, typeof(UsersReportCard))).Disability;
var commandBusiness = string.Format(selectFrames.Business, usersReportCard.Tab_num, $"{model.SettingParameters.Year}");
var userBusiness = sql.XmlString("Data Source=i7751-app020;Initial Catalog=imns51;Integrated Security=True;MultipleActiveResultSets=True", commandBusiness);
userBusiness = string.Concat("<UsersReportCard>", userBusiness, "</UsersReportCard>");
usersReportCard.Business = ((UsersReportCard)xml.ReadXmlText(userBusiness, typeof(UsersReportCard))).Business;
}
ReportCard report = new ReportCard();
report.CreateDocument("D:\\Testing\\", model);
}
public List <T> GetIDsBySP <T>(SqlConnectionType connectionType, string spName, params object[] parameters)
{
var result = new List <T>();
using (SqlConnection conn = GetSqlConnection(connectionType))
{
using (SqlDataReader dr = SqlHelper.ExecuteReader(conn, spName
, parameters))
{
result = SqlHelper.PopulateReadersToIds <T>(dr);
}
}
return(result);
}
/// <summary>
/// Полный анализ данных ЭПО с инвентаризацией запросы можно расширять
/// </summary>
/// <param name="pathSaveReport"></param>
/// <param name="idReport">Уникальные номера отчетов ЭПО</param>
/// <returns></returns>
public Stream CreateFullReportEpo(string pathSaveReport, int[] idReport)
{
var xlsx = new ReportExcel();
var sqlConnect = new SqlConnectionType();
var modelsReports = Inventory.AnalysisEpoAndInventarkas.Where(id => idReport.Contains(id.Id));
foreach (var modelReport in modelsReports)
{
var reportAnalysis = sqlConnect.ReportQbe(ConnectionString, modelReport.ViewReport);
xlsx.ReportAddListFile(modelReport.NameListXlsx, reportAnalysis);
}
Dispose(true);
xlsx.SaveAsFileXlsx(Path.Combine(pathSaveReport, "Полный анализ данных.xlsx"));
return(xlsx.DownloadFile(Path.Combine(pathSaveReport, "Полный анализ данных.xlsx")));
}
public SqlConnectionContext(SqlConnectionType connectiontype, SqlIsolationLevel sqlIsolationLevel)
{
lock (LockObject)
{
if (WebCallContext.GetData(ConnectionKey) == null)
{
WebCallContext.SetData(ConnectionKey, new SqlConnection(ConnectionString));
WebCallContext.SetData(IsolationLevelKey, sqlIsolationLevel);
}
else
{
throw new Exception("There is already a sql connection");
}
}
}
private TR ExecuteSql <TR>(string sql, SqlParameter[] sqlParameters, SqlConnectionType sqlConnectionType, Func <SqlCommand, TR> action)
{
var connStr = SqlConnectionPool.GetConnectionString(sqlConnectionType);
Console.WriteLine(connStr);
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
var command = new SqlCommand(sql, conn);
if (sqlParameters != null)
{
command.Parameters.AddRange(sqlParameters);
}
return(action.Invoke(command));
}
}
/// <summary>
/// Выборка Всех из БД B зависимости от номера 1: Пользователи 2: Отделы и т д
/// </summary>
/// <returns></returns>
public string SelectFull(ModelParametr.ModelParametr parametr)
{
var sqlconnect = new SqlConnectionType();
SerializeJson serializeJson = new SerializeJson();
switch (parametr.IdParamSelect)
{
case 1:
return
(serializeJson.JsonLibrary(
(AllUsers)
sqlconnect.SelectFullParametrSqlReader(Connection, Command.InfoLogic.NameProcedure,
typeof(AllUsers), ModelProcedure.ModelProcedure.ParamCommand(parametr.IdParamSelect.ToString()))));
default:
return(null);
}
}
/// <summary>
/// Процедуры выполнения создания КРСБ
/// </summary>
/// <param name="connection">Строка соединения</param>
/// <param name="seting">Настройки</param>
/// <returns></returns>
public async Task <string> TaskSqlProcedureKrsb(string connection, FullSetting seting)
{
var sqlconnect = new SqlConnectionType();
Dictionary <string, dynamic> listparametr = new Dictionary <string, dynamic>();
if (seting.DeloCreate.DateDelo != System.DateTime.MinValue)
{
listparametr.Add("@DateStart", seting.DeloCreate.DateDelo.Date);
}
if (seting.DeloCreate.D3979 != 0)
{
listparametr.Add("@D3979", seting.DeloCreate.D3979);
}
if (!String.IsNullOrWhiteSpace(seting.DeloCreate.Okato))
{
listparametr.Add("@Okato", seting.DeloCreate.Okato);
}
switch (seting.ParamService.IdCommand)
{
case 22:
if (seting.DeloPriem.DelaPriem.Count > 0)
{
//Добавляем в таблицу данные для дальнейшего анализа
AddKrsb krsb = new AddKrsb();
krsb.CreateDeloAnalizKrsb(seting.DeloPriem.DelaPriem);
}
return(await Task.Factory.StartNew(() => sqlconnect.StartingProcedure(connection, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connection, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand(seting.ParamService.IdCommand.ToString()))).ServiceWcfCommand.Command, listparametr)));
case 23:
return(await Task.Factory.StartNew(() => sqlconnect.StartingProcedure(connection, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connection, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand(seting.ParamService.IdCommand.ToString()))).ServiceWcfCommand.Command, listparametr)));
case 24:
return(await Task.Factory.StartNew(() => sqlconnect.StartingProcedure(connection, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connection, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand(seting.ParamService.IdCommand.ToString()))).ServiceWcfCommand.Command, listparametr)));
case 25:
return(await Task.Factory.StartNew(() => sqlconnect.StartingProcedure(connection, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connection, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand(seting.ParamService.IdCommand.ToString()))).ServiceWcfCommand.Command, listparametr)));
case 27:
return(await Task.Factory.StartNew(() => sqlconnect.StartingProcedure(connection, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connection, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand(seting.ParamService.IdCommand.ToString()))).ServiceWcfCommand.Command, listparametr)));
default:
return(null);
}
}
public static string GetConnectionString(SqlConnectionType sqlConnectionType)
{
string connStr = null;
switch (sqlConnectionType)
{
case SqlConnectionType.Write:
connStr = _writeConnStr;
break;
case SqlConnectionType.Read:
connStr = GetSqlConnectionsStringStrategy(_readConnStrs);
break;
default:
throw new Exception("未知的数据库连接类型");
}
return(connStr);
}
/// <summary>
/// Данные которые будут раскладываться на шаблоне
/// </summary>
/// <param name="conectionstring">Строка соединения с сервером</param>
/// <param name="connecttestsqlcommand">Строка соединения с таблицей комманд для запроса данных</param>
/// <param name="setting">Настроики пользователя</param>
/// <returns></returns>
public Report ReportBdk(string conectionstring, string connecttestsqlcommand, FullSetting setting)
{
try
{
var sqlconnect = new SqlConnectionType();
Dictionary <string, string> listparametr = new Dictionary <string, string>();
GenerateParametrSql.GenerateParametrSql sql = new GenerateParametrSql.GenerateParametrSql();
if (setting.ParametrBdkOut.D85DateStart != DateTime.MinValue)
{
sql.CreateParamert(ref listparametr, setting.ParametrBdkOut.GetType(), setting.ParametrBdkOut);
}
return((Report)sqlconnect.SelectFullParametrSqlReader(conectionstring, ((ServiceWcf)sqlconnect.SelectFullParametrSqlReader(connecttestsqlcommand, ModelSqlFullService.ProcedureSelectParametr, typeof(ServiceWcf), ModelSqlFullService.ParamCommand("11"))).ServiceWcfCommand.Command, typeof(Report), listparametr));
}
catch (Exception e)
{
Loggers.Log4NetLogger.Error(e);
}
return(null);
}
public static string GetConnectionString(SqlConnectionType sqlConnectionType)
{
string conn = null;
switch (sqlConnectionType)
{
case SqlConnectionType.Write:
conn = ConfigrationManager.SqlConnectionStringWrite;
break;
case SqlConnectionType.Read:
conn = Dispatcher(ConfigrationManager.SqlConnectionStringRead);
break;
default:
throw new Exception("wrong sqlConnectionType");
}
return(conn);
}
