//Запись мгновенного значения в DebugValues
private static void MomToRec(Moment mv, RecDao recv, int id)
{
if (mv == null)
{
return;
}
recv.AddNew();
recv.Put("DebugParamId", id);
if (mv.DataType == DataType.Time)
{
recv.Put("StrValue", mv.Date.ToStringWithMs());
}
else
{
if (mv.DataType == DataType.String)
{
recv.Put("StrValue", mv.String);
}
else
{
recv.Put("Value", mv.Real);
}
}
recv.Put("Time", mv.Time);
recv.Put("Nd", mv.Nd);
if (mv.Error != null)
{
recv.Put("ErrMess", mv.Error.ToString(), true);
}
recv.Update();
}
private static int CopyProp(RecDao cfgTemplate, RecDao cfg)
{
bool flag = !cfg.FindFirst("ParamName", cfgTemplate.GetString("ParamName"));
//if (!cfg.FindFirst("ParamName", cfgTemplate.GetString("ParamName")))
if (flag)
{
// MessageBox.Show("Я не нашел запись в конфиге, о чем сейчас и сообщаю");
//else MessageBox.Show("Я нашел запись в тимплейте. А вы чем занимаетесь?");
cfg.AddNew();
}
cfg.Put("ParamName", cfgTemplate.GetString("ParamName"));
cfg.Put("ParamType", cfgTemplate.GetString("ParamType"));
cfg.Put("ParamValue", cfgTemplate.GetString("ParamValue"));
cfg.Put("ParamDescription", cfgTemplate.GetString("ParamDescription"));
cfg.Put("ParamTag", cfgTemplate.GetString("ParamTag"));
int id = cfg.GetInt("ParamId");
//MessageBox.Show(flag + " " + cfgTemplate.GetString("ParamName"));
try
{
cfg.Update();
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
return(id);
}
//Запись в таблицы Params и SubParams, columns - список колонок таблицы Params
public void ToParamsTables(RecDao recParams, RecDao recSub, IEnumerable <VedColumn> columns)
{
recParams.AddNew();
foreach (var col in columns)
{
if (col.SourceType == ColumnSourceType.ResultValue && SubParams.ContainsKey(col.Code))
{
var m = SubParams[col.Code].LastMoment;
if (m.DataType != DataType.Value)
{
WriteValue(m, recParams, col.Code);
}
}
else if (col.SourceType == ColumnSourceType.ParamChar || col.SourceType == ColumnSourceType.SignalChar)
{
WriteProp(col, recParams);
}
}
_id = recParams.GetInt("IdParam");
recParams.Update();
foreach (var sub in SubParams.Keys)
{
recSub.AddNew();
recSub.Put("IdParam", _id);
recSub.Put("CodeSubParam", sub);
}
}
private void ToClone(RecDao rec)
{
rec.AddNew();
rec.Put("SignalId", IdInClone);
rec.Put("Time", _time);
rec.Put("Value", _val);
rec.Put("Nd", _nd);
rec.Update();
}
//Запись значений по параметру и подпараметрам в линейную ведомость, columns - список колонок таблицы LinVed
public void ToLinVed(RecDao rec, DicS <VedColumn> columns)
{
if (_param.RunParam.CalcValue == null || _param.RunParam.CalcValue.SingleValue == null)
{
return;
}
var par = _param.RunParam.CalcValue.SingleValue.ToMomList();
var subs = new List <VedMomList>();
foreach (var col in columns.Values)
{
if (SubParams.ContainsKey(col.Code))
{
subs.Add(new VedMomList(col.Code, SubParams[col.Code]));
}
}
foreach (var mom in par)
{
rec.AddNew();
rec.Put("IdParam", _id);
rec.Put("TimeValue", mom.Time);
rec.Put("TimeString", mom.Time.ToStringWithMs());
if (mom.DataType.LessOrEquals(DataType.Real))
{
if (columns.ContainsKey("ValueReal"))
{
rec.Put("ValueReal", mom.Real);
}
}
else if (columns.ContainsKey("ValueString"))
{
rec.Put("ValueString", mom.String);
}
if (rec.ContainsField("Nd"))
{
rec.Put("Nd", mom.Nd);
}
if (rec.ContainsField("ErrorString"))
{
rec.Put("ErrorString", mom.Error.Text);
}
foreach (var sub in subs)
{
WriteValue(sub.ChangeMoment(mom.Time), rec, sub.Code);
}
//foreach (var col in _vedSaver.ColumnsParams.Values)
// if (col.LinVedView != VedView.None)
// WriteProp(col, rec);
rec.Update();
}
}
private void ButAdd_Click(object sender, EventArgs e)
{
using (var rec = new RecDao(General.ReporterFile, "GroupReports"))
{
rec.AddNew();
rec.Put("GroupCode", "NewGroupReport");
GroupReports.SelectedItems.Clear();
var item = EditItem(rec);
item.Selected = true;
rec.Update();
var f = (FormGroupReportEdit)GeneralRep.RunReporterCommand(ReporterCommand.GroupReportEdit);
f.LoadGroup((int)item.Tag);
}
}
//Генерация по одной строке таблицы
public override void Generate(SubRows row)
{
_paramsRec.AddNew();
GenerateBase(row, _paramsRec);
_paramsRec.Put("Task", _task.GetText(row));
_paramsRec.Put("CalcParamType", _calcParamType.GetText(row));
_paramsRec.Put("DefaultValue", _defaultValue.GetText(row));
int id = _paramsRec.GetInt("CalcParamId");
_paramsRec.Update();
foreach (var sp in SubParams)
{
sp.GenerateParams(row, SubParamsRec, id);
}
}
//Запись SingleValue в DebugParams и DebugValues, возвращает записываемую ошибку, adderr - для записи сообщения об ошибке в подпараметрах
public void ValuesToRec(string realCode, string debugType, int paramId, Dictionary <string, string> variables, SingleValue sv, string adderr = "")
{
if (sv == null)
{
return;
}
_rec.AddNew();
_rec.Put("ProjectProvider", _projectProvider);
_rec.Put("Code", realCode);
_rec.Put("ResultType", sv.DataType.ToRussian());
_rec.Put("DebugParamType", debugType);
_rec.Put("ParamId", paramId);
if (variables != null)
{
_rec.Put("Variables", variables.ToPropertyString());
}
var err = sv.LastError;
if (err.IsEmpty())
{
err = adderr;
}
else
{
err += "; " + adderr;
}
_rec.Put("ErrMess", err, true);
_rec.Put("Value", SvToStr(sv));
_rec.Put("MomentsCount", sv.Type == SingleType.Moment ? 1 : (sv.Moments == null ? 0 : sv.Moments.Count));
int id = _rec.GetInt("DebugParamId");
_rec.Update();
if (_thread.IsSaveValues)
{
if (sv.Type == SingleType.Moment)
{
MomToRec(sv.Moment, _recv, id);
}
if (sv.Type == SingleType.List && sv.Moments != null)
{
foreach (var mv in sv.Moments)
{
MomToRec(mv, _recv, id);
}
}
}
}
//Записывает параметр в таблицу
public void ToRecordset(RecDao rec, bool addnew)
{
try
{
if (addnew)
{
rec.AddNew();
}
rec.Put("CalcParamId", FirstParam.CalcParamId);
bool b = FirstParam != LastParam;
if (b)
{
rec.Put("CalcSubParamId", LastParam.CalcParamId);
}
var par = LastParam ?? FirstParam;
rec.Put("SuperProcessType", par.SuperProcess.ToRussian());
var dt = par.CalcType.DataType.AplySuperProcess(par.SuperProcess);
rec.Put("DataType", dt.ToRussian());
if (dt == DataType.Integer || dt == DataType.Real)
{
rec.Put("Units", par.Units.IsEmpty() ? FirstParam.Units : par.Units);
rec.Put("Min", par.Min ?? FirstParam.Min);
rec.Put("Max", par.Max ?? FirstParam.Max);
}
if (dt == DataType.Real)
{
rec.Put("DecPlaces", par.DecPlaces ?? FirstParam.DecPlaces);
}
if (FirstParam.Tablik.Prevs.ContainsKey(FullCode))
{
FirstParam.Tablik.Prevs[FullCode].Id = rec.GetInt("Id");
}
rec.Put("FullCode", FullCode);
rec.Update();
}
catch {}
//catch//Повтор архивных параметров
//{
// using ( var recc = new RecDao(FirstParam.Tablik.ProjectFile, "SELECT CalcParams.ErrMess FROM CalcParams WHERE CalcParamId=" + FirstParam.CalcParamId))
// {
// if (recc.GetString("ErrMess").IsEmpty()) FirstParam.Tablik.ErrorsCount++;
// recc.Put("ErrMess", "По данному параметру формируется два архивных параметра с одинаковым кодом (" + FullCode + ")");
// }
//}
}
public bool SaveSate(Dictionary <string, object> state)
{
if (_daoDb != null)
{
_daoDb.Execute("DELETE * FROM " + SubTableName);
_daoDb.Execute("DELETE * FROM " + MainTableName);
string stringSql = "SELECT * FROM " + MainTableName + ";";
using (var rsMain = new RecDao(_daoDb, stringSql))
{
stringSql = "SELECT * FROM " + SubTableName + ";";
using (var rsSub = new RecDao(_daoDb, stringSql))
{
foreach (var propKey in state.Keys)
{
int id;
int num = 0;
foreach (var propState in (List <Dictionary <string, string> >)state[propKey])
{
rsMain.AddNew();
rsMain.Put(FieldPropType, propKey);
rsMain.Put(FieldPropName, ++num);
rsMain.Update();
rsMain.MoveLast();
id = rsMain.GetInt("Id");
foreach (var subProp in propState.Keys)
{
rsSub.AddNew();
rsSub.Put(FieldPropId, id);
rsSub.Put(FieldSubPropName, subProp);
rsSub.Put(FieldSubPropValue, propState[subProp]);
}
}
}
}
}
return(true);
}
return(false);
}
public void ToRecordset(RecDao rec)
{
rec.AddNew();
rec.Put("Id", Id);
rec.Put("Description", Description);
rec.Put("Params", Params);
rec.Put("Time", DateTime.Parse(Time));
rec.Put("Command", _command);
rec.Put("Context", _context);
if (_periodBegin != null)
{
rec.Put("PeriodBegin", _periodBegin);
}
if (_periodEnd != null)
{
rec.Put("PeriodEnd", _periodEnd);
}
rec.Update();
}
private void butAddThread_Click(object sender, RoutedEventArgs e)
{
try
{
using (var rec = new RecDao(General.ControllerFile, "Threads"))
{
rec.AddNew();
rec.Put("ApplicationType", ApplicationType.Controller.ToEnglish());
rec.Put("IsPeriodic", true);
var d = DateTime.Now.ToString();
rec.Put("TimeAdd", d);
rec.Put("TimeChange", d);
rec.Update();
rec.MoveLast();
App.AddThread(rec);
}
}
catch (Exception ex)
{
ex.MessageError("Ошибка создания потока");
}
}
private void butOK_Click(object sender, EventArgs e)
{
using (_book.StartAtom("Сохранение настроек"))
{
_book.AddEvent("Сохранение настроек отчета");
if (CodeReport.Text.IsEmpty())
{
Different.MessageError("Код отчета должен быть заполнен");
return;
}
int res;
bool er = (!MonthLength.Text.IsEmpty() && (!int.TryParse(MonthLength.Text, out res) || res < 0));
er |= (!DayLength.Text.IsEmpty() && (!int.TryParse(DayLength.Text, out res) || res < 0));
er |= (!HourLength.Text.IsEmpty() && (!int.TryParse(HourLength.Text, out res) || res < 0));
er |= (!MinuteLength.Text.IsEmpty() && (!int.TryParse(MinuteLength.Text, out res) || res < 0));
er |= (!DayStart.Text.IsEmpty() && (!int.TryParse(DayStart.Text, out res) || res < 0));
er |= (!HourStart.Text.IsEmpty() && (!int.TryParse(HourStart.Text, out res) || res < 0));
er |= (!MinuteLength.Text.IsEmpty() && (!int.TryParse(MinuteLength.Text, out res) || res < 0));
if (er)
{
Different.MessageError("Указана недопустимая длительность или начало интеравала");
return;
}
var sys = _book.SysPage;
bool isInternal = false;
try
{
sys.PutValue("Report", CodeReport.Text);
sys.PutValue("ReportName", NameReport.Text);
sys.PutValue("ReportDescription", DescriptionReport.Text);
sys.PutControl(MonthLength);
sys.PutControl(DayLength);
sys.PutControl(HourLength);
sys.PutControl(MinuteLength);
sys.PutControl(DayStart);
sys.PutControl(HourStart);
sys.PutControl(MinuteStart);
sys.PutValue("DifferentLength", radioDifferent.Checked ? "True" : (radioLess.Checked ? "Less" : "Equals"));
if (radioNow.Checked)
{
sys.PutValue("DefaultPeriod", "Now");
}
if (radioPrevious.Checked)
{
sys.PutValue("DefaultPeriod", "Previous");
}
sys.PutValue("DifferentBegin", DifferentBegin.Checked);
sys.PutValue("DefaultCalcName", CalcName.Text);
sys.PutValue("AllowProjectsRepetitions", AllowProjectsRepetitions.Checked);
var list = new List <ReportProjectSetup>();
foreach (DataGridViewRow r in Projects.Rows)
{
if (!r.IsNewRow)
{
try
{
var cmode = r.Get("ProjectCalcMode").ToCalcModeType();
isInternal |= cmode == CalcModeType.Internal;
list.Add(new ReportProjectSetup(r.Get("Project"), AllowProjectsRepetitions.Checked ? r.Get("ProjectCode2") : null, cmode));
}
catch { }
}
}
sys.PutProjects(list);
}
catch (Exception ex)
{
GeneralRep.ShowError("Текущий файл не является файлом отчета InfoTask или был поврежден", ex);
}
try { tabMain.Select(); } catch {}
_codes.Clear();
_infs.Clear();
foreach (DataGridViewRow row in Providers.Rows)
{
string name = row.Get("ProviderName");
_codes.Add(name, row.Get("ProviderCode"));
_infs.Add(name, row.Get("ProviderInf"));
}
int tid;
if (!int.TryParse(ThreadId.Text, out tid))
{
tid = 0;
}
if (isInternal)
{
try
{
_book.AddEvent("Сохранение настроек в ControllerData");
using (var db = new DaoDb(General.ControllerFile))
{
using (var rec = new RecDao(db, "SELECT * FROM Threads WHERE ThreadId=" + tid))
{
if (!rec.HasRows())
{
rec.AddNew();
}
rec.Put("ApplicationType", "Excel");
rec.Put("IsImit", IsImit.Checked);
rec.Put("ImitMode", ImitMode.Text);
tid = rec.GetInt("ThreadId");
}
db.Execute("DELETE * FROM Providers WHERE ThreadId=" + tid);
db.Execute("DELETE * FROM Projects WHERE ThreadId=" + tid);
using (var rec = new RecDao(db, "Projects"))
using (var recc = new RecDao(db, "Providers"))
{
foreach (DataGridViewRow row in Projects.Rows)
{
if (!row.IsNewRow && row.Get("ProjectCalcMode").ToCalcModeType() == CalcModeType.Internal)
{
rec.AddNew();
rec.Put("ThreadId", tid);
rec.PutFromDataGrid("Project", row);
rec.PutFromDataGrid("ProjectFile", row);
}
}
foreach (DataGridViewRow row in Providers.Rows)
{
if (row.Get("TypeProvider") != "Архив" || row.Get("ProviderName") == "CalcArchive" || (row.Get("ProviderName") == "Report_Archive" && UseOneArchive.Checked))
{
recc.AddNew();
recc.Put("ThreadId", tid);
recc.PutFromDataGrid("ProviderType", row, "TypeProvider");
recc.PutFromDataGrid("ProviderCode", row);
if (row.Get("ProviderName") != "Report_Archive")
{
recc.PutFromDataGrid("ProviderName", row);
}
else
{
recc.Put("ProviderName", "CalcArchive");
}
recc.PutFromDataGrid("ProviderInf", row);
recc.Update();
}
}
}
}
}
catch (Exception ex)
{
GeneralRep.ShowError("Неправильный файл ControllerData.accdb", ex);
return;
}
}
_book.AddEvent("Сохранение настроек в ReporterData");
try //Настройки отчета в ReporterData
{
using (var db = new DaoDb(General.ReporterFile))
{
using (var rec = new RecDao(db, "SELECT * FROM Reports WHERE Report = '" + CodeReport.Text + "'"))
{
if (!rec.HasRows())
{
rec.AddNew();
}
rec.Put("Report", CodeReport.Text);
rec.Put("ReportName", NameReport.Text);
rec.Put("ReportDescription", DescriptionReport.Text);
rec.Put("ReportFile", GeneralRep.Application.ActiveWorkbook.FullName);
rec.Put("ThreadId", isInternal ? tid : 0);
rec.Put("UseOneArchive", UseOneArchive.Checked);
rec.Put("CodeArchive", _codes["Report_Archive"]);
rec.Put("InfArchive", _infs["Report_Archive"]);
string s = "FormTo=" + (FormToTemplate.Checked ? "Template" : (FormToDir.Checked ? "Dir" : "File")) + ";";
s += "ResultDir=" + ResultDir.Text + ";";
s += "ResultFileName=" + ResultFileName.Text + ";";
s += "ResultFile=" + ResultFile.Text + ";";
s += "AddDateToName=" + (AddDateToName.Checked ? "True" : "False") + ";";
var df = DateNameFormat.Text;
if (AddDateToName.Checked && (df.Contains(":") || df.Contains(@"\") || df.Contains(@"/") || df.Contains("[") || df.Contains("]") || df.Contains("*")))
{
Different.MessageError(@"Указан недопустимый формат даты для имени файла или листа. Имя не должно содержать символов / \ : * [ ]");
return;
}
s += "DateNameFormat=" + df + ";";
s += "AddBeginToName=" + (AddBeginToName.Checked ? "True" : "False") + ";";
df = BeginNameFormat.Text;
if (AddBeginToName.Checked && (df.Contains(":") || df.Contains(@"\") || df.Contains(@"/") || df.Contains("[") || df.Contains("]") || df.Contains("*")))
{
Different.MessageError(@"Указан недопустимый формат даты для имени файла или листа. Имя не должно содержать символов / \ : * [ ]");
return;
}
s += "BeginNameFormat=" + df + ";";
s += "AddEndToName=" + (AddEndToName.Checked ? "True" : "False") + ";";
df = EndNameFormat.Text;
if (AddEndToName.Checked && (df.Contains(":") || df.Contains(@"\") || df.Contains(@"/") || df.Contains("[") || df.Contains("]") || df.Contains("*")))
{
Different.MessageError(@"Указан недопустимый формат даты для имени файла или листа. Имя не должно содержать символов / \ : * [ ]");
return;
}
s += "EndNameFormat=" + df + ";";
s += "AddCalcNameToName=" + (AddCalcNameToName.Checked ? "True" : "False") + ";";
s += "AddSheetToName=" + (AddSheetToName.Checked ? "True" : "False") + ";";
s += "SetFocusToFormed=" + (SetFocusToFormed.Checked ? "True" : "False") + ";";
rec.Put("FormInf", s);
rec.Put("ServerReport", ServerReport.Text);
if (!ServerReport.Text.IsEmpty())
{
var file = new FileInfo(ServerReport.Text);
if (!file.Exists || file.Extension != ".xlsx")
{
Different.MessageError("Указанный файл контрольного экземпляра не существует или не является файлом Excel, " + ServerReport.Text);
}
else if (ServerReport.Text == _book.Workbook.FullName)
{
Different.MessageError("Файл контрольного бланка расчета не должен совпадать с файлом бланка отчета, " + ServerReport.Text);
}
}
int rid = rec.GetInt("ReportId");
rec.Update();
db.Execute("DELETE * FROM Projects WHERE ReportId=" + rid);
using (var recp = new RecDao(db, "Projects"))
foreach (DataGridViewRow r in Projects.Rows)
{
if (!r.IsNewRow)
{
recp.AddNew();
recp.Put("ReportId", rid);
recp.PutFromDataGrid("Project", r);
if (AllowProjectsRepetitions.Checked)
{
recp.PutFromDataGrid("ProjectCode2", r);
}
recp.PutFromDataGrid("ProjectName", r);
recp.PutFromDataGrid("ProjectFile", r);
if (UseOneArchive.Checked)
{
recp.Put("CodeArchive", _codes["Report_Archive"]);
recp.Put("InfArchive", _infs["Report_Archive"]);
}
else if (r.Get("ProjectCalcMode").ToCalcModeType() == CalcModeType.Internal)
{
recp.Put("CodeArchive", _codes["CalcArchive"]);
recp.Put("InfArchive", _infs["CalcArchive"]);
}
else
{
var proj = r.Get("Project");
if (AllowProjectsRepetitions.Checked && !r.Get("ProjectCode2").IsEmpty())
{
proj = r.Get("ProjectCode2");
}
proj += "_Archive";
recp.Put("CodeArchive", _codes[proj]);
recp.Put("InfArchive", _infs[proj]);
}
}
}
}
}
}
catch (Exception ex)
{
GeneralRep.ShowError("Неправильный файл ReporterData.accdb", ex);
}
_book.ClearReportDataFromMemory();
CheckProviders();
Close();
}
}
//Сохранение одной ссылки
private void SaveLink(Comment c, Shape sh, RecDao rp, RecDao rc, RecDao rs, Worksheet sheet)
{
var dic = (sh == null ? c.Text() : sh.Title).ToPropertyDicS();
if (dic != null && dic.ContainsKey("Field") && dic.ContainsKey("Project") && dic.ContainsKey("Code"))
{
LinkType linkType = dic["LinkType"].ToLinkType();
var projcode = dic["Project"];
string parcode = dic["Code"];
if (Projects.ContainsKey(projcode))
{
ReportProjectForLinks proj = Projects[projcode];
ReportParam param = null;
if (proj.IsSave)
{
//Сохранение
if (proj.Params.ContainsKey(parcode))
{
param = proj.Params[parcode];
}
else
{
rp.AddNew();
param = new ReportParam(projcode, new ArchiveParam(parcode, DataType.String, null,
new CalcParamBase(parcode, dic["CellComment"]), new CalcParamBase(dic["Field"])))
{
Id = rp.GetInt("ParamId")
};
rp.Put("Project", projcode);
rp.Put("Code", parcode);
rp.Put("CodeParam", parcode);
rp.Put("DataType", DataType.String.ToRussian());
rp.Put("IsUsed", true);
rp.Put("IsHandInput", false);
proj.Params.Add(parcode, param);
rp.Update();
}
}
else if (proj.Params.ContainsKey(parcode))
{
param = proj.Params[parcode];
if (linkType == LinkType.HandInput)
{
//Ручной ввод
param.IsHandInput = true;
proj.IsHandInput = true;
}
else
{
//Обычное получние данных
param.IsUsed = true;
proj.IsUsed = true;
}
}
if (param != null)
{
var itype = IntervalType.Empty;
if (proj.CalcMode == CalcModeType.Internal)
{
if (linkType == LinkType.Result || linkType == LinkType.MomentsList)
{
itype = IntervalType.Single;
}
}
else
{
switch (linkType)
{
case LinkType.Combined:
case LinkType.CombinedList:
if (dic.ContainsKey("LengthMinute") || dic.ContainsKey("PartBeginMinute") ||
dic.ContainsKey("PartEndMinute"))
{
itype = IntervalType.Base;
}
else if (dic.ContainsKey("LengthHour") || dic.ContainsKey("PartBeginHour") ||
dic.ContainsKey("PartEndHour"))
{
itype = IntervalType.Hour;
}
else if (dic.ContainsKey("LengthDay") || dic.ContainsKey("PartByTime"))
{
itype = IntervalType.Day;
}
else
{
itype = IntervalType.Combined;
}
break;
case LinkType.Absolute:
case LinkType.AbsoluteEdit:
itype = IntervalType.Absolute;
break;
case LinkType.AbsoluteCombined:
itype = IntervalType.AbsoluteCombined;
break;
case LinkType.AbsoluteList:
if (dic.ContainsKey("LengthMinute") && dic["LengthMinute"].ToInt() != 0)
{
itype = IntervalType.AbsoluteListBase;
}
else if (dic.ContainsKey("LengthHour") && dic["LengthHour"].ToInt() != 0)
{
itype = IntervalType.AbsoluteListHour;
}
else
{
itype = IntervalType.AbsoluteListDay;
}
break;
case LinkType.MomentsList:
case LinkType.Result:
itype = IntervalType.Moments;
break;
}
}
if (!param.IntervalTypes.Contains(itype))
{
param.IntervalTypes.Add(itype);
}
if (sh == null)
{
//Добавление в таблицу Cells
rc.AddNew();
rc.Put("Page", sheet.Name);
rc.Put("Y", ((Range)c.Parent).Row);
rc.Put("X", ((Range)c.Parent).Column);
rc.Put("LinkType", linkType.ToEnglish());
rc.Put("LinkField", dic["Field"]);
if (dic.ContainsKey("AllowEdit"))
{
rc.Put("AllowEdit", dic["AllowEdit"] == "True");
}
string prop = "";
foreach (var k in dic.Keys)
{
if (k != "LinkType" && k != "Field" && k != "Project" && k != "Code")
{
prop += k + "=" + dic[k] + ";";
}
}
rc.Put("Properties", prop);
rc.Put("ParamId", param.Id);
rc.Put("IntervalType", itype.ToRussian());
rc.Put("SaveCode", dic["SaveCode"]);
rc.Update();
}
else
{
//Добавление в таблицу Shapes
rs.AddNew();
rs.Put("Page", sheet.Name);
rs.Put("ShapeId", sh.ID);
rs.Put("ShapeType", sh.Type.ToEnglish());
if (sh.Type == MsoShapeType.msoGroup)
{
rs.Put("Formula", sh.AlternativeText);
}
rs.Put("LinkType", linkType.ToEnglish());
rs.Put("LinkField", dic["Field"]);
string prop = "";
foreach (var k in dic.Keys)
{
if (k != "LinkType" && k != "Field" && k != "Project" && k != "Code")
{
prop += k + "=" + dic[k] + ";";
}
}
rs.Put("Properties", prop);
rs.Put("ParamId", param.Id);
rs.Put("IntervalType", itype.ToRussian());
rs.Update();
}
}
}
}
}
//Запись значений ручного ввода, beg - начало периода расчета
public void WriteHandInput(DateTime beg, DateTime en)
{
if (IsHandInput)
{
try
{
Book.AddEvent("Сохрание значений ручного ввода из ячеек", CodeFinal);
var pars = new DicS <ReportHandParam>();
foreach (var param in Params.Values)
{
if (param.HandInputCell != null)
{
pars.Add(param.FullCode,
new ReportHandParam(param, GeneralRep.ActiveBook.ValueFromCell(param.HandInputCell)));
}
}
using (var db = new DaoDb(_handInputFile))
{
using (
var rec = new RecDao(db,
"SELECT Objects.CodeObject, MomentsValues.Time FROM (Objects INNER JOIN Signals ON Objects.ObjectId = Signals.ObjectId) INNER JOIN MomentsValues ON Signals.SignalId = MomentsValues.SignalId " +
"WHERE (Time >= " + beg.ToAccessString() + ") AND (Time < " + en.ToAccessString() + ")"))
while (rec.Read())
{
if (pars.ContainsKey(rec.GetString("CodeObject")))
{
rec.Put("Time", Different.MaxDate);
}
}
using (
var rec = new RecDao(db,
"SELECT Objects.CodeObject, MomentsStrValues.Time FROM (Objects INNER JOIN Signals ON Objects.ObjectId = Signals.ObjectId) INNER JOIN MomentsStrValues ON Signals.SignalId = MomentsStrValues.SignalId " +
"WHERE (Time >= " + beg.ToAccessString() + ") AND (Time < " + en.ToAccessString() + ")"))
while (rec.Read())
{
if (pars.ContainsKey(rec.GetString("CodeObject")))
{
rec.Put("Time", Different.MaxDate);
}
}
db.Execute("DELETE * FROM MomentsValues WHERE Time=" + Different.MaxDate.ToAccessString());
db.Execute("DELETE * FROM MomentsStrValues WHERE Time=" + Different.MaxDate.ToAccessString());
using (
var rec = new RecDao(db,
"SELECT Objects.CodeObject, Objects.ObjectId, Signals.CodeSignal, Signals.SignalId FROM Objects INNER JOIN Signals ON Objects.ObjectId = Signals.SignalId")
)
while (rec.Read())
{
var code = rec.GetString("CodeObject");
if (pars.ContainsKey(code))
{
pars[code].ObjectId = rec.GetInt("ObjectId");
pars[code].SignalId = rec.GetInt("SignalId");
}
}
using (var reco = new RecDao(db, "Objects"))
using (var recs = new RecDao(db, "Signals"))
foreach (var param in pars.Values)
{
if (param.ObjectId == 0)
{
var ap = param.ReportParam.ArchiveParam;
var par = ap.FirstParam;
reco.AddNew();
reco.Put("CodeObject", par.Code);
reco.Put("NameObject", par.Name);
param.ObjectId = reco.GetInt("ObjectId");
reco.Update();
recs.AddNew();
recs.Put("ObjectId", param.ObjectId);
recs.Put("CodeSignal", "Руч");
recs.Put("NameSignal", "Ручной ввод");
recs.Put("FullCode", par.Code + ".Руч");
recs.Put("Default", true);
recs.Put("DataType", ap.DataType.ToRussian());
recs.Put("Units", ap.Units);
recs.Put("Min", ap.Min);
recs.Put("Max", ap.Max);
recs.Put("Active", true);
param.SignalId = recs.GetInt("SignalId");
recs.Update();
}
}
using (var rec = new RecDao(db, "MomentsValues"))
using (var recs = new RecDao(db, "MomentsStrValues"))
foreach (var param in pars.Values)
{
if (!param.StringValue.IsEmpty())
{
var dt = param.ReportParam.ArchiveParam.DataType;
var r = dt.LessOrEquals(DataType.Real) ? rec : recs;
r.AddNew();
r.Put("SignalId", param.SignalId);
r.Put("Time", beg);
if (dt.LessOrEquals(DataType.Real))
{
var d = param.StringValue.ToDouble();
if (!double.IsNaN(d))
{
r.Put("Value", d);
}
else
{
r.Put("Value", 0);
r.Put("Nd", 1);
}
}
else if (dt == DataType.String)
{
r.Put("StrValue", param.StringValue);
}
else if (dt == DataType.Time)
{
var t = param.StringValue.ToDateTime();
r.Put("TimeValue", t);
if (t == Different.MinDate)
{
r.Put("Nd", 1);
}
}
}
}
using (var sys = new SysTabl(db, false))
{
var d = sys.Value("BeginInterval").ToDateTime();
if (d == Different.MinDate || d > beg)
{
sys.PutValue("BeginInterval", beg.ToString());
}
d = sys.Value("EndInterval").ToDateTime();
if (d < beg)
{
sys.PutValue("EndInterval", beg.ToString());
}
}
}
}
catch (Exception ex)
{
Book.AddError("Ошибка при записи ручного ввода", ex);
}
}
}
//Компиляция проекта, возвращает количество ошибок компиляции
public string CompileProject()
{
//OnlyOn = true;
CountsToZero();
if (State == State.Project || State == State.Empty)//Если не загружены, то загружаем сигналы
{
string s = LoadSignals();
if (s != "")
{
return(s);
}
}
else
{
foreach (var sig in SignalsList)
{
sig.InUse = false;
sig.InUseSource = false;
sig.InUseReceiver = false;
}
}
StartAtom(Atom.CompileProject);
if (State == State.Closed)
{
AddError("Копилятор уже был закрыт");
}
else
{
try
{
//Обнуления поля Expr и т.п.
using (var daodb = new DaoDb(_projectFile))
{
//daodb.Execute("UPDATE CalcParams SET CalcParams.Expr = Null, CalcParams.ErrMess = Null, CalcParams.UsedUnits = Null, CalcParams.CalcNumber = 0;");
foreach (string tab in new[] { "CalcParams", "CalcSubParams" })
{
using (var rec = new RecDao(daodb, tab))
while (rec.Read())
{
rec.Put("Expr", (string)null);
try { rec.Put("UsedUnits", (string)null); } catch { }
rec.Put("CalcNumber", 0);
rec.Put("ErrMess", (string)null);
rec.Update();
}
}
CalcParams.Clear();
CalcParamsId.Clear();
CalcParamsAll.Clear();
Grafics.Clear();
ArchiveParams.Clear();
Prevs.Clear();
HandSignals.Clear();
CalcParamNumber = 0;
Procent = 10;
AddEvent("Загрузка графиков");
using (var rec = new RecDao(daodb, "SELECT GraficsList.Code, GraficsList.Dimension FROM GraficsList"))
while (rec.Read())
{
var gr = new Grafic(rec.GetString("Code"), rec.GetInt("Dimension"));
Grafics.Add(gr.Code, gr);
}
Procent = 15;
AddEvent("Загрузка параметров");
string spar = OnlyOn ? "WHERE (CalcOn = True) And (TaskOn = True)" : "";
using (var rec = new RecDao(daodb, "SELECT CalcParams.* FROM CalcParams " + spar + " ORDER BY CalcParamId"))
while (rec.Read())
{
new CalcParam(rec, this);
}
Procent = 25;
AddEvent("Загрузка подпараметров");
string ssub = OnlyOn ? "WHERE (CalcParams.CalcOn = True) And (CalcParams.TaskOn = True) And (CalcSubParams.CalcOn = True)" : "";
using (var rec = new RecDao(daodb, "SELECT CalcSubParams.* FROM CalcParams INNER JOIN CalcSubParams ON CalcParams.CalcParamId = CalcSubParams.OwnerId " + ssub))
while (rec.Read())
{
new CalcParam(rec, this, true);
}
Procent = 35;
AddEvent("Разбор выражений");
foreach (var cp in CalcParamsId.Values)
{
cp.Parse();
}
IsPrevAbs = false;
IsLastBase = false;
IsLastHour = false;
IsLastDay = false;
IsManyBase = false;
IsManyHour = false;
IsManyDay = false;
IsManyMoments = false;
Procent = 45;
AddEvent("Компиляция выражений");
foreach (var cp in CalcParamsId.Values)
{
if (cp.Stage == CompileStage.NotStarted)
{
cp.Compile(null);
}
/*foreach (var d in cp.MethodsId.Values)
* if (d.Stage == CompileStage.NotStarted)
* d.Compile(null);*/
}
FindCycleLinks();
ErrorsCount = 0;
UsedProviders = new SetS();
IsAbsolute = false;
IsPeriodic = false;
IsMoments = false;
Procent = 60;
AddEvent("Сохранение результатов компиляции параметров");
using (var rec = new RecDao(daodb, "SELECT CalcParams.* FROM CalcParams " + spar + " ORDER BY CalcParamId"))
SaveCompile(rec, false);
Procent = 70;
AddEvent("Сохранение результатов компиляции подпараметров");
using (var rec = new RecDao(daodb, "SELECT CalcSubParams.* FROM CalcParams INNER JOIN CalcSubParams ON CalcParams.CalcParamId = CalcSubParams.OwnerId " + ssub + " ORDER BY CalcParams.CalcParamId;"))
SaveCompile(rec, true);
}
Procent = 80;
AddEvent("Сохранение списка используемых сигналов и графиков");
SaveInUse();
Procent = 90;
AddEvent("Сохранение архивных параметров");
SaveArchive();
Procent = 96;
AddEvent("Сохранение параметров функций Пред");
SavePrevs();
Procent = 99;
SaveUsedProviders();
using (var sys = new SysTabl(_projectFile))
{
sys.PutSubValue("CompileStatus", "LastTimeCompile", DateTime.Now.ToString());
sys.PutSubValue("CompileStatus", "ErrorsCount", ErrorsCount.ToString());
}
}
catch (Exception ex)
{
AddError("Ошибка компилятора", ex);
}
}
return(FinishAtom(State.Compiled, State.Signals, "Проект: " + _code + "; Ошибок: " + ErrorsCount + ";" + Different.NewLine
+ "Параметров: " + CalcParamsId.Count + "; Архивных параметров:" + ArchiveParams.Count + "; Сигналов: " + SignalsInUseCount));
}
//Сохранение в файл клона
public void ValuesToClone()
{
using (var db = new DaoDb(_cloneFile))
{
int id;
using (var rec = new RecDao(db, "SELECT * FROM Objects WHERE CodeObject='" + Code + "'"))
{
if (!rec.HasRows())
{
rec.AddNew();
}
rec.Put("CodeObject", Code);
rec.Put("NameObject", Name);
rec.Put("Comment", Comment);
id = rec.GetInt("ObjectId");
}
using (var rec = new RecDao(db, "SELECT * FROM Signals WHERE ObjectId=" + id))
{
if (!rec.HasRows())
{
rec.AddNew();
}
rec.Put("ObjectId", id);
rec.Put("CodeSignal", "Руч");
rec.Put("NameSignal", "Ручной ввод");
rec.Put("FullCode", Code + ".Руч");
rec.Put("Default", true);
rec.Put("DataType", DataType);
rec.Put("Units", Units);
rec.Put("Active", true);
id = rec.GetInt("SignalId");
rec.Update();
}
var dt = DataType.ToDataType();
DateTime mind = Different.MaxDate, maxd = Different.MinDate;
RecDao recv;
if (dt.LessOrEquals(BaseLibrary.DataType.Real))
{
db.Execute("DELETE * FROM MomentsValues WHERE SignalId=" + id);
recv = new RecDao(db, "SELECT * FROM MomentsValues WHERE SignalId=" + id);
}
else
{
db.Execute("DELETE * FROM MomentsStrValues WHERE SignalId=" + id);
recv = new RecDao(db, "SELECT * FROM MomentsStrValues WHERE SignalId=" + id);
}
using (recv)
foreach (var v in HandInputValues)
{
v.ToRecordset(recv, id, dt);
if (v.TimeCorrect && v.Time.ToDateTime() < mind)
{
mind = v.Time.ToDateTime();
}
if (v.TimeCorrect && v.Time.ToDateTime() > maxd)
{
maxd = v.Time.ToDateTime();
}
}
if (mind != Different.MaxDate)
{
using (var sys = new SysTabl(db, false))
{
var d = sys.Value("BeginInterval").ToDateTime();
if (d == Different.MinDate || d > mind)
{
sys.PutValue("BeginInterval", mind.ToString());
}
d = sys.Value("EndInterval").ToDateTime();
if (d < maxd)
{
sys.PutValue("EndInterval", maxd.ToString());
}
}
}
}
}