/// <summary>
/// Constuctor
/// </summary>
/// <param name="connection">KaRaFa database connection</param>
/// <param name="karafaSettings">KaRaFa settings</param>
public AdministrationForm(DatabaseConnection connection, KarafaSettings karafaSettings)
{
InitializeComponent();
this.dbConnection = connection;
this.settings = karafaSettings;
this.btn_Delete.IsEnabled = false;
this.btn_Edit.IsEnabled = false;
this.dg_Users.SelectionChanged += new SelectionChangedEventHandler(dg_Users_SelectionChanged);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="chimneyModule">Chimney module</param>
/// <param name="automaticConstructions">Instace to preocess saving</param>
/// <param name="connection">Database connection</param>
public ChimneyModuleForm(
ChimneyModule chimneyModule,
AutomaticConstructions automaticConstructions,
DatabaseConnection connection)
{
InitializeComponent();
this.chimneyModule = chimneyModule;
this.dbConnection = connection;
this.automaticConstructions = automaticConstructions;
this.currentConstructionList = automaticConstructions.ChimneyConstructions;
this.dg_Constructions.ItemsSource = automaticConstructions.ChimneyConstructions;
}
/// <summary>
/// Loads modules from database
/// </summary>
/// <param name="connection"></param>
public void LoadModules(DatabaseConnection connection)
{
try
{
string query = connection.CreateSelectCommandText(
Properties.Resources.VIEW_ATC_MODULES,
null,
null,
"ID asc"
);
DataSet dataSet = connection.ExecuteSelectQuery(query);
if (dataSet == null || dataSet.Tables.Count == 0 || dataSet.Tables[0].Rows.Count == 0)
return;
// Fill dictionary with modules
foreach (DataRow definition in dataSet.Tables[0].Rows)
{
ModuleTypeEnum type = (ModuleTypeEnum)Enum.Parse(typeof(ModuleTypeEnum), definition["Enum"].ToString());
switch (type)
{
case ModuleTypeEnum.SdkModule:
if (!this.Modules.ContainsKey(type))
this.Modules.Add(type, new SdkModule(definition));
break;
case ModuleTypeEnum.ChimneyModule:
if (!this.Modules.ContainsKey(type))
this.Modules.Add(type, new ChimneyModule(definition));
break;
case ModuleTypeEnum.RoofModule:
if (!this.Modules.ContainsKey(type))
this.Modules.Add(type, new RoofModule(definition));
break;
default:
break;
}
}
}
catch (Exception ex)
{
Karafa.Errors.KarafaLogger.LogError(ex);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="connection">Database connection</param>
/// <param name="constructions">Construction list for selection user control</param>
/// <param name="moduleDictionary">Modules for automatic calculation</param>
public CostsCalculationForm(
DatabaseConnection connection,
List<Construction> constructions,
ModuleDictionary moduleDictionary)
{
InitializeComponent();
this.dbConnection = connection;
this.moduleDictionary = moduleDictionary;
// User control needs to work with the same dictionary of constructions
ConstructionMultiCombo uc = this.uc_constructionMultiCombo;
uc.ConstructionList = constructions;
uc.ParentWindow = this;
uc.ConstructionSelectedEvent += OnConstructionSelected;
uc.VariationSelectedEvent += OnVariationSelected;
uc.ObjectSelectedEvent += OnObjectSelected;
uc.CalculationSelectedEvent += OnCalculationSelected;
// At the beginning disable this functionality
SetImportedItemsControlsEnability(false);
this.dg_SubSections.SelectionChanged += new SelectionChangedEventHandler(OnSubSectionSelectionChanged);
this.dg_ImportedItems.SelectionChanged += new SelectionChangedEventHandler(OnCalculationSelectionChanged);
}
/// <summary>
/// Composes connection string from values
/// </summary>
/// <returns>Return valid connection string or NULL</returns>
private string GetConnectionString()
{
string connectionString = string.Format(
"Data Source={0}; Initial Catalog={1}; User Id={2}; Password={3}",
this.tbx_Server.Text,
this.tbx_Database.Text,
this.tbx_UserName.Text,
this.tbx_Password.Password
);
DatabaseConnection connection = new DatabaseConnection(connectionString);
if (connection.OpenConnection())
return connectionString;
return null;
}
/// <summary>
/// Loads default subsections from KaRaFa database
/// </summary>
/// <param name="connection">Connection to KaRaFa database</param>
public void LoadDefaultSubSections(DatabaseConnection connection)
{
if (connection == null || !connection.IsConnectionOpen)
return;
try
{
string query = connection.CreateSelectCommandText(
Properties.Resources.VIEW_SUBSECTIONS,
null,
null,
null
);
// Load subsections from DB
DataSet dataSet = connection.ExecuteSelectQuery(query);
if (dataSet == null || dataSet.Tables.Count == 0 || dataSet.Tables[0].Rows.Count == 0)
return; // Nothong found
// Create subsections
foreach (DataRow row in dataSet.Tables[0].Rows)
{
this.SubSections.Add(
new SubSection(
(int)row["ID"],
(string)row["Nazev"],
(int)row["EtapaID"]
)
);
}
}
catch (Exception ex)
{
Karafa.Errors.KarafaLogger.LogError(ex);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="connection">KaRaFa database connection</param>
public LoginProcess(DatabaseConnection connection)
{
this.dbConnection = connection;
}
/// <summary>
/// When construction is being saved, corresponding MainItem has to be updated
/// </summary>
/// <param name="connection">Database connection</param>
/// <param name="construction">Construction to update/add</param>
public void UpdateSdkConstructionMainItem(DatabaseConnection connection, SdkConstruction construction)
{
// Get index of Constructions -> MainItem is on the same index
int index =
this.SdkConstructions == null
? -1
: this.SdkConstructions.IndexOf(construction);
// Get new Main Item
MainItem result = new SdkModule(null).CalculateConstruction(connection, construction, index);
// New item
if (index == -1)
{
this.SdkConstructions.Add(construction);
this.SdkMainItems.Add(result);
return;
}
// Old result
this.SdkMainItems[index] = result;
}
/// <summary>
/// Loads <see cref="Karafa.Modules.AutomaticCalculation.Base.ModuleOption"/>s from databse
/// and binds them to proper comboboxes.
/// Selections without superior option are binded dierctly to proper comboboxes.
/// </summary>
/// <param name="connection">Database connection</param>
/// <param name="optionsBoxes">ComboBoxes to which Options are binded</param>
public void LoadAndBindOption(DatabaseConnection connection, ComboBox[] optionsBoxes)
{
// Load Options from database only for the first time
if (this.Options.Count == 0)
LoadOptions(connection);
// Nothing to bind
if (optionsBoxes == null || optionsBoxes.Length == 0)
return;
// Init
this.optionComboBoxes.Clear();
// Register ComboBoxes for Options into HashTable
foreach (ComboBox box in optionsBoxes)
{
// Adds to HashTable
RegisterOptionComboBox(box);
}
// Bind Options without superior Option
foreach (ModuleOption option in this.Options)
{
// Add option to proper combobox
if (string.IsNullOrEmpty(option.SuperiorOption))
{
string id = option.OptionNumber.ToString();
if (this.optionComboBoxes.ContainsKey(id))
((ComboBox)this.optionComboBoxes[id]).Items.Add(option);
}
}
}
/// Updates materials needed in Chimney construction
/// </summary>
/// <param name="connection">Database connection</param>
/// <param name="construction">Chímney construction to calculate</param>
/// <param name="index">Number of constructions in module</param>
/// <returns>Returns MainItems list calculated from constructions</returns>
public MainItem CalculateConstruction(DatabaseConnection connection, ChimneyConstruction construction, int index)
{
// Result
MainItem chimneyMainItem = new MainItem();
chimneyMainItem.Analysis = new ItemAnalysis();
chimneyMainItem.ID = string.Format("{0}-{1}", Properties.Resources.MAIN_ITEM_ID_CHIMNEY, index);
chimneyMainItem.Name = construction.Name;
chimneyMainItem.MeasureUnit = Properties.Resources.LABEL_CHIMNEY_MEASURE_UNIT;
chimneyMainItem.Quantity = 1;
chimneyMainItem.Kind = Properties.Resources.TEXT_KIND_CHIMNEY;
// Get construction result code to load materials
string resultCode = construction.ResultCode;
if (string.IsNullOrEmpty(resultCode))
{
chimneyMainItem.Note = Properties.Resources.MESSAGE_NO_MATERIAL_FOUND;
return chimneyMainItem;
}
// New material set
Hashtable materials = new Hashtable();
// Create MainItem for every construction
// Load materials related to construction result code
DataSet materialRelations =
connection.GetMaterialSourcesForAutomaticConstructions(resultCode);
if (materialRelations == null)
{
chimneyMainItem.Note = Properties.Resources.MESSAGE_NO_MATERIAL_FOUND;
return chimneyMainItem;
}
try
{
// Browse all loaded materials
foreach (DataRow relatedMaterial in materialRelations.Tables[0].Rows)
{
// All columns are marked as NOT NULL in databse
string materialID = relatedMaterial["MaterialID"] as string;
string dimension = relatedMaterial["Rozmer"] as string;
decimal usage =
Utilities.StringUtils.ParseDecimalFromString(
relatedMaterial["Mnozstvi"].ToString(),
0
);
// Load material from database by id
DataSet materialSet =
connection.GetMaterialById(materialID);
if (materialSet == null || materialSet.Tables[0].Rows.Count == 0)
continue; // No material found
// Create Material
MaterialItem material =
new MaterialItem(materialSet.Tables[0].Rows[0]);
material.UsageMeasureUnit =
Utilities.StringUtils.GetUsageMeasureUnit(
material.MeasureUnit,
chimneyMainItem.MeasureUnit
);
// Set its usage and quantity based on coeficient from database and quantity from construction
SetChimneyMaterialUsage(material, construction, dimension.Trim(), usage);
material.Quantity = chimneyMainItem.CountAnalyzedItemQuantity(material.Usage);
// Adds material to new hashtable result
// Material can be new, or can be already used -> sum their quantities
AddMaterialToHashTable(materials, material, construction.Name);
}
// Update material list an unit price
UpdateList(chimneyMainItem, materials);
chimneyMainItem.CalculateUnitPrice();
}
catch (Exception ex)
{
Karafa.Errors.KarafaLogger.LogError(ex);
}
// Return result
return chimneyMainItem;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sdkModule">Sdk module</param>
/// <param name="automaticConstructions">Instance to process saving</param>
/// <param name="connection">Database connection</param>
public SdkModuleForm(
SdkModule sdkModule,
AutomaticConstructions automaticConstructions,
DatabaseConnection connection)
{
InitializeComponent();
this.sdkModule = sdkModule;
this.dg_Losts.ItemsSource = "";
this.dbConnection = connection;
this.automaticConstructions = automaticConstructions;
this.currentConstructions = automaticConstructions.SdkConstructions;
this.dg_Constructions.ItemsSource = automaticConstructions.SdkConstructions;
}
/// <summary>
/// Loads initial analysis when displayed on analysis grid on analysis grid
/// </summary>
/// <param name="databaseConnection">Database connection</param>
public void LoadInitialAnalysis(DatabaseConnection databaseConnection)
{
if (this.Analysis.ItemAnalysisList != null && this.Analysis.ItemAnalysisList.Count > 0)
return; // Analysis has already been loaded from database
this.Analysis.LoadAnalysisFromDatabase(databaseConnection, this.ID);
}
/// <summary>
/// Updates Materials needed in SDK construction
/// </summary>
/// <param name="connection">Database connection</param>
/// <param name="construction">SDK Construction to calculate</param>
/// <param name="index">Count of constructions in module</param>
/// <returns>Returns list of MainItems woth porcessed constructions</returns>
public MainItem CalculateConstruction(DatabaseConnection connection, SdkConstruction construction, int index)
{
// Result
MainItem sdkMainItem = new MainItem();
sdkMainItem.ID = string.Format("{0}-{1}", Properties.Resources.MAIN_ITEM_ID_SDK, index);
sdkMainItem.Name = construction.Name;
sdkMainItem.MeasureUnit = Properties.Resources.LABEL_SDK_MEASURE_UNIT;
sdkMainItem.Kind = Properties.Resources.TEXT_KIND_SDK;
// Get construction result code to load materials from database
string resultCode = construction.ResultCode;
//No code, no material
if (string.IsNullOrEmpty(resultCode))
{
sdkMainItem.Note = Properties.Resources.MESSAGE_NO_MATERIAL_FOUND;
return sdkMainItem;
}
// New set of materials
Hashtable materials = new Hashtable();
// Get materials ID related to construction Result code
DataSet materialRelations =
connection.GetMaterialSourcesForAutomaticConstructions(resultCode);
if (materialRelations == null)
{
sdkMainItem.Note = Properties.Resources.MESSAGE_NO_MATERIAL_FOUND;
return sdkMainItem;
}
try
{
// Compose materials from all SdkBoard from construction
foreach (SdkBoard board in construction.SdkBoards)
{
board.Spacing = construction.Spacing;
// Browse all related materials
foreach (DataRow relatedMaterial in materialRelations.Tables[0].Rows)
{
// All columns are marked as NOT NULL in databse
string materialID = relatedMaterial["MaterialID"] as string;
string dimension = relatedMaterial["Rozmer"] as string;
decimal usage =
Utilities.StringUtils.ParseDecimalFromString(
relatedMaterial["Mnozstvi"].ToString(),
0
);
// Load material by its ID
DataSet materialSet =
connection.GetMaterialById(materialID);
if (materialSet == null || materialSet.Tables[0].Rows.Count == 0)
continue; // No material found
// Create Material
MaterialItem material =
new MaterialItem(materialSet.Tables[0].Rows[0]);
material.UsageMeasureUnit =
Utilities.StringUtils.GetUsageMeasureUnit(
material.MeasureUnit,
sdkMainItem.MeasureUnit
);
// Set its usage and quantity based on coeficient from database and quantity from construction
SetSdkMaterialUsage(material, board, dimension.Trim(), usage);
// Adds material to new hashtable result
// Material can be new, or can be already used -> sum their quantities
AddMaterialToHashTable(materials, material, construction.Name);
}
}
// Get surface quantity and its expression
string expession = string.Empty;
decimal quantity = 0;
CountSurface(construction, out quantity, ref expession);
// Set proper data to MainItem
sdkMainItem.Quantity += quantity;
sdkMainItem.QuantityExpression += expession;
// Aktualize material list and unit price
UpdateList(sdkMainItem, materials);
UpdateMaterialsCalculations(sdkMainItem);
// Calculate initial UnitPrice of MainItem
sdkMainItem.CalculateUnitPrice();
}
catch (Exception ex)
{
Karafa.Errors.KarafaLogger.LogError(ex);
}
// Return result
return sdkMainItem;
}
/// <summary>
/// Gets definition for related item from a proper view
/// </summary>
/// <param name="connection">Database connection</param>
/// <param name="viewName">View name</param>
/// <param name="id">Id of related item</param>
/// <returns></returns>
private DataRow GetRelatedItemByAnalysis(DatabaseConnection connection, string viewName, string id)
{
return connection.GetSingleItem(viewName, id);
}
/// <summary>
/// Loads options from database related to this module
/// </summary>
/// <param name="connection">KaRaFa Database connection</param>
private void LoadOptions(DatabaseConnection connection)
{
try
{
// Get Options query
string query = connection.CreateSelectCommandText(
Properties.Resources.VIEW_ATC_OPTIONS,
null,
string.Format("ModulID = {0}", this.ID),
"ID ASC"
);
// Get results
DataSet dataSet = connection.ExecuteSelectQuery(query);
if (dataSet == null || dataSet.Tables.Count == 0 || dataSet.Tables[0].Rows.Count == 0)
return;
// Save options
foreach (DataRow definition in dataSet.Tables[0].Rows)
{
ModuleOption option = new ModuleOption(definition);
this.Options.Add(option);
}
}
catch (Exception ex)
{
Karafa.Errors.KarafaLogger.LogError(ex);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="item">MainItem to be shown</param>
/// <param name="connection">Karafa database connection</param>
/// <param name="form">Parent CostCalculationForm</param>
/// <param name="formSubSection">Currently selected SubSection on parent form</param>
public MainItemDetailForm(
MainItem item,
DatabaseConnection connection,
CostsCalculationForm form,
SubSection formSubSection)
{
InitializeComponent();
this.detailedItem = item;
this.dbConnection = connection;
this.calculationForm = form;
this.currentSubsection = formSubSection;
this.Title = string.Format("{0} - {1}", this.Title, this.detailedItem.Name);
this.evaluator = new ExpressionEvaluator(this.tbx_QuantityCounter, this.tbx_QuantityResults);
this.loaded = false;
this.shouldRecalculateAnalysisQuantity = false;
}
/// <summary>
/// Loads default etaps set from database
/// </summary>
/// <param name="connection">Database connection</param>
/// <param name="constructionStartDate">Start date of parent construciton</param>
/// <param name="constructionEndDate">End date of parent construciton</param>
public void LoadEtaps(
DatabaseConnection connection,
DateTime constructionStartDate,
DateTime constructionEndDate)
{
if (connection == null || !connection.IsConnectionOpen)
return;
try
{
string query = connection.CreateSelectCommandText(
"Etapy",
null,
null,
null
);
// Load etaps from DB
DataSet dataSet = connection.ExecuteSelectQuery(query);
if (dataSet == null || dataSet.Tables.Count == 0 || dataSet.Tables[0].Rows.Count == 0)
{
// Nothong found -> create one default etap
this.Etaps.Add(
new Etap(
Properties.Settings.Default.DefaultEtapID,
"Etapa",
constructionStartDate,
constructionEndDate
)
);
return;
}
HarmonogramManager manager = new HarmonogramManager();
// Set start and end dates of etap based on their setting
foreach (DataRow row in dataSet.Tables[0].Rows)
{
DateTime startDate, endDate;
manager.CountEtapData(
constructionStartDate,
constructionEndDate,
(byte)row["Zacatek"],
(byte)row["Konec"],
out startDate,
out endDate
);
this.Etaps.Add(
new Etap(
(int)row["ID"],
(string)row["Nazev"],
startDate,
endDate
)
);
}
}
catch (Exception ex)
{
Karafa.Errors.KarafaLogger.LogError(ex);
}
}
