public void DeleteMaterial(int id)
        {
            m_materialRepository.DeleteMaterial(id);

            m_cache.Remove(GetMappablesCacheKey());
            m_materialRepository.CleanCache();
            m_virtualProductRepository.CleanCache();
        }
        public IVirtualProduct ProcessVirtualProductEditRequest(int?virtualProductId, string name, string[] materialEntries)
        {
            using (var tx = m_database.OpenTransaction())
            {
                var requestMaterials = ProcessMaterialEntries(materialEntries).ToList();

                var cnt =
                    requestMaterials
                    .GroupBy(m => m.Material.Name)
                    .Select(g => new { Material = g.Key, Count = g.Count() })
                    .FirstOrDefault(g => g.Count > 1);

                if (cnt != null)
                {
                    throw new ArgumentException($"Materiál \"{cnt.Material}\" nesmí být k tagu připojen více než jednou");
                }

                var vp = m_virtualProductRepository.CreateOrUpdateVirtualProduct(virtualProductId, name);

                using (var materialRepository = m_materialRepository.GetWithPostponedCache())
                {
                    var existingMaterials = m_materialRepository.GetMaterialsByVirtualProductId(vp.Id).ToList();

                    //disconnections:
                    var toDetach = existingMaterials.Where(m => requestMaterials.All(rqm => rqm.Material.Id != m.Material.Id))
                                   .ToList();

                    foreach (var dtch in toDetach)
                    {
                        materialRepository.DetachMaterial(vp.Id, dtch.Material.Id);
                        existingMaterials.Remove(dtch);
                    }

                    //updates:
                    foreach (var requestComponent in requestMaterials)
                    {
                        materialRepository.AddOrUpdateComponent(
                            vp.Id,
                            requestComponent.Material.Id,
                            requestComponent.Amount,
                            requestComponent.Unit.Id);
                    }
                }

                tx.Commit();

                m_virtualProductRepository.CleanCache();

                return(vp);
            }
        }
Exemple #3
0
        public IExtendedMaterialModel ProcessMaterialEditRequest(int?materialId,
                                                                 string name,
                                                                 string nominalAmountText,
                                                                 int materialInventoryId,
                                                                 bool automaticBatches,
                                                                 bool requiresPrice,
                                                                 bool requiresProductionPrice,
                                                                 bool requiresIncvoice,
                                                                 bool requiresSupplierReference,
                                                                 bool autofinalize,
                                                                 bool canBeDigital,
                                                                 IEnumerable <string> components,
                                                                 string thresholdText
                                                                 )
        {
            name = name?.Trim();

            if (string.IsNullOrWhiteSpace(name))
            {
                throw new InvalidOperationException("Materiál musí mít název");
            }

            if (string.IsNullOrWhiteSpace(nominalAmountText))
            {
                throw new ArgumentException("Materiál musí mít vlastní množství a jednotku");
            }

            var nominalAmountEntry = MaterialEntry.Parse(nominalAmountText, true);

            var nominalUnit = ValidateAmountUnit(nominalAmountEntry);

            using (var tx = m_database.OpenTransaction())
            {
                var material = m_materialRepository.UpsertMaterial(
                    materialId,
                    name,
                    nominalAmountEntry.Amount,
                    nominalUnit.Id,
                    materialInventoryId,
                    automaticBatches,
                    requiresPrice,
                    requiresProductionPrice,
                    requiresIncvoice,
                    requiresSupplierReference, autofinalize, canBeDigital);

                if (thresholdText == null)
                {
                    m_materialThresholdRepository.DeleteThreshold(material.Id);
                }
                else
                {
                    try
                    {
                        var thresholdEntry = MaterialEntry.Parse(thresholdText, true);

                        var thresholdUnit = m_unitRepository.GetUnitBySymbol(thresholdEntry.UnitName);
                        if (thresholdUnit == null)
                        {
                            throw new InvalidOperationException($"Neznámý symbol jednotky \"{thresholdEntry.UnitName}\"");
                        }

                        m_materialThresholdRepository.SaveThreshold(material.Id,
                                                                    thresholdEntry.Amount,
                                                                    thresholdUnit.Id);
                    }
                    catch (Exception ex)
                    {
                        throw new InvalidOperationException($"Nelze nastavit sledování minimálního množství - {ex.Message}", ex);
                    }
                }

                tx.Commit();
                m_virtualProductRepository.CleanCache();
                m_materialRepository.CleanCache();
                return(m_materialRepository.GetMaterialById(material.Id));
            }
        }