public IList<usp_getClientAsset_Result> GetClientAssetList(ClientAsset clientAsset)
 {
     IList<usp_getClientAsset_Result> fetchedClient = new List<usp_getClientAsset_Result>();
     try
     {
         //using (var Context = new Cubicle_EntityEntities())
         //{
         //    IQueryable<usp_getClientAsset_Result> query = Context.usp_getClientAsset(0).AsQueryable<usp_getClientAsset_Result>();
         //    if (clientAsset.ClientAssetName != string.Empty)
         //        query = query.Where(p => p.ClientAssetName.ToUpper().Contains(clientAsset.ClientAssetName.ToUpper()));
         //    if (clientAsset.ClientAssetCode != string.Empty)
         //        query = query.Where(p => p.ClientAssetCode.ToUpper().Contains(clientAsset.ClientAssetCode.ToUpper()));
         //    if (clientAsset.ClientID != 0)
         //        query = query.Where(p => p.ClientID == clientAsset.ClientID);
         //    fetchedClient = query.ToList();
         //}
     }
     catch (Exception ex)
     {
         //bool false = BusinessLogicExceptionHandler.HandleException(ref ex);
         if (false)
         {
             throw ex;
         }
     }
     return fetchedClient;
 }
 public Boolean CheckDuplicate(ClientAsset clientAsset, Boolean IsInsert)
 {
     Boolean Result = true;
     try
     {
         var c = _clientAssetRepository.GetSingle(p => p.ClientAssetName.ToUpper() == clientAsset.ClientAssetName.ToUpper() && p.ClientAssetCode.ToUpper() == clientAsset.ClientAssetCode.ToUpper() && p.ClientID == clientAsset.ClientID);
         if (!IsInsert)
         {
             if (c == null)
                 Result = true;
             else if (c.ClientAssetID == clientAsset.ClientAssetID)
                 Result = true;
             else
                 Result = false;
         }
         else
         {
             if (c == null)
                 Result = true;
             else
                 Result = false;
         }
     }
     catch (Exception ex)
     {
         //bool false = BusinessLogicExceptionHandler.HandleException(ref ex);
         if (false)
         {
             throw ex;
         }
     }
     return Result;
 }
        public IActionResult Post([FromBody] ClientAsset value)
        {
            if (ModelState.IsValid == false)
            {
                return(BadRequest(ModelState));
            }

            value = repo.Create(AuthMan.GetAccountId(this), value);
            return(CreatedAtAction("Get", value));
        }
        public void WhenInstantiatingClassWithDefaultConstructor_Succeeds()
        {
            // Arrange
            ClientAsset model;

            // Act
            model = new ClientAsset();

            // Assert
            Assert.NotNull(model);
        }
        public async Task <IActionResult> Put([FromBody] ClientAsset value)
        {
            if (ModelState.IsValid == false)
            {
                return(BadRequest(ModelState));
            }

            var res = await repo.UpdateAsync(AuthMan.GetAccountId(this), value);

            if (res == null)
            {
                return(NotFound());
            }
            return(Ok(value));
        }
        public IActionResult SaveClientAsset([FromBody] ClientAsset model)
        {
            if (model == null)
            {
                return(BadRequest("Something bad happened."));
            }
            try
            {
                ClientAsset clientAssetName = new ClientAsset();
                clientAssetName.ClientName = model.ClientName;
                clientAssetName.AssetName  = model.AssetName;
                clientAssetName.Reference  = model.Reference;
                clientAssetName.DateStamp  = DateTime.Now;

                _context.ClientAssetNames.Add(clientAssetName);
                _context.SaveChanges();
            }
            catch (Exception Ex)
            {
                return(BadRequest("Something bad happened. " + Ex.Message));
            }

            return(Ok());
        }