Exemplo n.º 1
0
        public async Task <IActionResult> PutUser(long id, User user)
        {
            if (id != user.Id)
            {
                return(BadRequest());
            }

            _context.Entry(user).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UserExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Exemplo n.º 2
0
        public async Task <IActionResult> PutAssetNotes(long id, AssetNotes assetNotes)
        {
            if (id != assetNotes.IdNote)
            {
                return(BadRequest());
            }

            _context.Entry(assetNotes).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AssetNotesExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutAcquisitionMethod(int id, AcquisitionMethod acquisitionMethod)
        {
            if (id != acquisitionMethod.ID)
            {
                return(BadRequest());
            }

            _context.Entry(acquisitionMethod).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AcquisitionMethodExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutConfiguration(int id, Configuration configuration)
        {
            if (id != configuration.IdConfig)
            {
                return(BadRequest());
            }

            _context.Entry(configuration).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ConfigurationExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <ActionResult <IEnumerable <Asset> > > GetDepreciation(int id, bool project)
        {
            var depreciation = await _context.Depreciations.FindAsync(id);

            var    _assets = _context.Assets.Where(x => x.Depreciation.Id == id);
            string oldDetails, newDetails;

            if (depreciation == null)
            {
                return(NotFound());
            }

            foreach (var a in _assets)
            {
                var _newPrice = a.CurrentPrice - (a.CurrentPrice * depreciation.Percentage);
                oldDetails     = a.ToString();
                a.CurrentPrice = _newPrice;
                newDetails     = a.ToString();
                if (!project)
                {
                    _context.AssetsHistory.Add(new AssetHistory()
                    {
                        AssetID = a.Id, NewDetails = newDetails, PreviewsDetails = oldDetails, UpdateDate = DateTime.Now
                    });
                }
            }
            if (!project)
            {
                await _context.SaveChangesAsync();
            }

            return(_assets.ToList());
        }
Exemplo n.º 6
0
 public async Task InsertASMasterProductType(ASMasterProductType objADMasterProductType)
 {
     try
     {
         _Context.ASMasterProductTypes.Add(objADMasterProductType);
         await _Context.SaveChangesAsync();
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Exemplo n.º 7
0
 public async Task InsertASMasterCategory(ASMasterCategory objADMasterCategory)
 {
     try
     {
         _Context.ASMasterCategories.Add(objADMasterCategory);
         await _Context.SaveChangesAsync();
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Exemplo n.º 8
0
 public async Task InsertASMasterBrand(ASMasterBrand objADMasterBrand)
 {
     try
     {
         _Context.ASMasterBrands.Add(objADMasterBrand);
         await _Context.SaveChangesAsync();
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Exemplo n.º 9
0
        public async Task <IActionResult> PutLocation(int id, Location location)
        {
            if (id != location.ID)
            {
                return(BadRequest());
            }

            var _old = _context.Locations.FirstOrDefault(x => x.ID == id);

            if (_old.Responsible1 == null && _old.Responsible2 == null)
            {
                setReponsibleByLocation(location);
            }
            else if (_old.Responsible1.ID != location.Responsible1.ID && _old.Responsible2.ID != location.Responsible1.ID &&
                     _old.Responsible1.ID != location.Responsible2.ID && _old.Responsible2.ID != location.Responsible2.ID)
            {
                setReponsibleByLocation(location);
            }
            else if (_old.Responsible1.ID != location.Responsible1.ID && _old.Responsible1.ID != location.Responsible2.ID)
            {
                setReponsibleByLocation(location, true, false);
            }
            else if (_old.Responsible2.ID != location.Responsible1.ID && _old.Responsible2.ID != location.Responsible2.ID)
            {
                setReponsibleByLocation(location, false, true);
            }
            _old.Responsible1 = location.Responsible1;
            _old.Responsible2 = location.Responsible2;

            _context.Entry(_old).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!LocationExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Exemplo n.º 10
0
        public async Task <IActionResult> PutAsset(long id, Asset asset)
        {
            if (id != asset.Id)
            {
                return(BadRequest());
            }

            var _asset = await _context.Assets.FindAsync(id);

            var props = typeof(Asset).GetProperties();

            _context.AssetsHistory.Add(new AssetHistory()
            {
                AssetID = asset.Id, NewDetails = asset.ToString(), PreviewsDetails = _asset.ToString(), UpdateDate = DateTime.Now, Action = "Edit"
            });

            foreach (var prop in props)
            {
                prop.SetValue(_asset, prop.GetValue(asset));
            }

            _context.Entry(_asset).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AssetExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task InsertASTransactionProductHistory(ASTransactionProductHistory objADTransactionProductHistory)
        {
            using (var transaction = _Context.Database.BeginTransaction())
            {
                try
                {
                    _Context.ASTransactionProductHistorys.Add(objADTransactionProductHistory);
                    await _Context.SaveChangesAsync();

                    ASMasterProductChild objASMasterProductChild = _Context.ASMasterProductChilds.Find(objADTransactionProductHistory.MasterProductChildId);
                    objASMasterProductChild.WarrantyExpiryDate = objADTransactionProductHistory.SubscriptionExpiryDate;

                    _Context.Entry(objASMasterProductChild).State = EntityState.Modified;
                    await _Context.SaveChangesAsync();

                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw new Exception(ex.Message);
                }
            }
        }
 public async Task InsertASMasterAssetsAssignment(ASMasterAssetsAssignment objADMasterAssetsAssignment)
 {
     try
     {
         _Context.ASMasterAssetsAssignments.Add(objADMasterAssetsAssignment);
         await _Context.SaveChangesAsync();
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Exemplo n.º 13
0
        public async Task InsertASMasterProduct(ASMasterProductMerge objASMasterProductMerge)
        {
            using (var transaction = _Context.Database.BeginTransaction())
            {
                try
                {
                    ASMasterProduct          objASMasterProduct          = objASMasterProductMerge.ASMasterProduct;
                    ASMasterProductChild     objASMasterProductChild     = objASMasterProductMerge.ASMasterProductChild;
                    ASMasterAssetsAssignment objASMasterAssetsAssignment = objASMasterProductMerge.ASMasterAssetsAssignment;

                    _Context.ASMasterProducts.Add(objASMasterProduct);
                    await _Context.SaveChangesAsync();

                    objASMasterProductChild.MasterProductId   = objASMasterProduct.MasterProductId;
                    objASMasterProductChild.ProductChildTitle = objASMasterProduct.ProductTitle;
                    objASMasterProductChild.IsActive          = true;
                    objASMasterProductChild.IsDeadAssets      = false;
                    objASMasterProductChild.IsSaleProduct     = false;
                    _Context.ASMasterProductChilds.Add(objASMasterProductChild);

                    await _Context.SaveChangesAsync();

                    //Insert in TransactionProductHistory
                    ASTransactionProductHistory objASTransactionProductHistory = new ASTransactionProductHistory();
                    if (objASMasterProductChild.MasterEmployeeId != null && objASMasterProductChild.MasterEmployeeId > 0)
                    {
                        objASTransactionProductHistory.MasterProductChildId       = objASMasterProductChild.MasterProductChildId;
                        objASTransactionProductHistory.MasterSubscriptionTypeId   = 1;
                        objASTransactionProductHistory.MasterSubscriptionVendorId = objASMasterProductChild.MasterVendorId;
                        objASTransactionProductHistory.SubscriptionPrice          = objASMasterProductChild.PurchasePrice;
                        objASTransactionProductHistory.SubscriptionDate           = objASMasterProductChild.PurchaseDate;
                        objASTransactionProductHistory.SubscriptionStartDate      = objASMasterProductChild.WarrantyStartDate;
                        objASTransactionProductHistory.SubscriptionExpiryDate     = objASMasterProductChild.WarrantyExpiryDate;

                        _Context.ASTransactionProductHistorys.Add(objASTransactionProductHistory);
                        await _Context.SaveChangesAsync();
                    }


                    if (objASMasterProductChild.MasterEmployeeId != null && objASMasterProductChild.MasterEmployeeId > 0)
                    {
                        //ASMasterAssetsAssignment
                        objASMasterAssetsAssignment.MasterAssetsAssignmentId = 0;
                        objASMasterAssetsAssignment.IsActive             = true;
                        objASMasterAssetsAssignment.AssetsAssignmentDate = objASMasterAssetsAssignment.AssetsAssignmentDate;
                        objASMasterAssetsAssignment.MasterProductChildId = objASMasterProductChild.MasterProductChildId;
                        objASMasterAssetsAssignment.MasterEmployeeId     = objASMasterProductChild.MasterEmployeeId;

                        _Context.ASMasterAssetsAssignments.Add(objASMasterAssetsAssignment);
                        await _Context.SaveChangesAsync();
                    }

                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw new Exception(ex.Message);
                }
            }
        }
 public async Task <bool> SaveChangeAsync()
 {
     return((await _context.SaveChangesAsync()) > 0);
 }