public async Task <IHttpActionResult> putValidator(int id, DTOvalidator dtovalidator)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != dtovalidator.Validator_ID)
            {
                return(BadRequest());
            }

            var putValidator = db.validators.Single(e => e.Validator_ID == id);

            db.Entry(EntityMapper.updateEntity(putValidator, dtovalidator)).State = EntityState.Modified;

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

            return(StatusCode(HttpStatusCode.NoContent));
        }
        public async Task <DTOvalidator> Postvalidator(DTOvalidator newDTO)
        {
            validator newProd = EntityMapper.updateEntity(null, newDTO);

            db.validators.Add(newProd);
            await db.SaveChangesAsync();

            return(newDTO);
        }
        public async Task <IHttpActionResult> Putvalidator(int ID, DTOvalidator editedDTO)
        {
            validator toUpdate = db.validators.Find(ID);

            toUpdate = EntityMapper.updateEntity(toUpdate, editedDTO);
            db.Entry(toUpdate).State = EntityState.Modified;
            await db.SaveChangesAsync();

            return(StatusCode(HttpStatusCode.NoContent));
        }
        public async Task <IHttpActionResult> getValidator(int id)
        {
            DTOvalidator toReturn = new DTOvalidator(await db.validators.FindAsync(id));

            if (toReturn == null)
            {
                return(NotFound());
            }
            return(CreatedAtRoute("DefaultApi", new { id = toReturn.Validator_ID }, toReturn));
        }
        public async Task <IHttpActionResult> postValidator(DTOvalidator dtovalidator)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.validators.Add(EntityMapper.updateEntity(null, dtovalidator));
            await db.SaveChangesAsync();

            return(CreatedAtRoute("DefaultApi", new { id = dtovalidator.Validator_ID }, dtovalidator));
        }
Esempio n. 6
0
        public static validator updateEntity(validator entityObjct, DTOvalidator dto)
        {
            if (entityObjct == null)
            {
                entityObjct = new validator();
            }

            entityObjct.Validator_ID             = dto.Validator_ID;
            entityObjct.User_ID                  = dto.User_ID;
            entityObjct.validatiorCompany        = dto.validatiorCompany;
            entityObjct.validatorLicenseNumber   = dto.validatorLicenseNumber;
            entityObjct.validatorLicenseProvider = dto.validatorLicenseProvider;
            entityObjct.validatorValidUntil      = dto.validatorValidUntil;
            entityObjct.validatorVATNumber       = dto.validatorVATNumber;
            entityObjct.validatorAddress         = dto.validatorAddress;
            entityObjct.validatorBankName        = dto.validatorBankName;
            entityObjct.validatorBankAccNumber   = dto.validatorBankAccNumber;
            entityObjct.validatorBankBranchName  = dto.validatorBankBranchName;
            entityObjct.validatorBankBranchCode  = dto.validatorBankBranchCode;

            return(entityObjct);
        }