// GET: api/DateRages
public IHttpActionResult Get()
{
IHttpActionResult response;
LogDTO log = new LogDTO()
{
Request = Request.RequestUri.PathAndQuery,
Date = DateTime.Now,
RequestMethod = "GET"
};
try
{
var ranges = dateRangeDTOService.GetAll();
log.ResponseStatus = (int)HttpStatusCode.OK;
log.ResponseDataCount = ranges.Count();
response = Ok(ranges);
}
catch (Exception ex)
{
log.ResponseStatus = (int)HttpStatusCode.BadRequest;
response = BadRequest(ex.Message);
}
logDTOService.Add(log);
logDTOService.Save();
return(response);
}
public void Add_CallsAddOnPermissionService()
{
// Arrange
// Act
_entityService.Add(new List <DummyEntity>());
// Assert
_permissionService.Verify(x => x.Add());
}
public void Create(Product product)
{
using (var transaction = _productRepository.BeginTransaction())
{
_productRepository.Add(product);
_productRepository.SaveChange();
_entityService.Add(product.Name, product.SeoTitle, product.Id, ProductEntityTypeId);
_productRepository.SaveChange();
transaction.Commit();
}
}
public void Create(Product product)
{
using (var transaction = _productRepo.BeginTransaction())
{
product.SeoTitle = _entityService.ToSafeSlug(product.SeoTitle, product.Id, ProductEntityTypeId);
_productRepo.Add(product);
_productRepo.SaveChanges();
_entityService.Add(product.Name, product.SeoTitle, product.Id, ProductEntityTypeId);
_productRepo.SaveChanges();
transaction.Commit();
}
}
public async Task <IActionResult> Add([FromBody] EntityViewModel model)
{
var entity = _mapper.Map <Entity>(model);
await _entityService.Add(entity);
return(Ok());
}
public void Upload(IEntityService <Paper> service)
{
Status = true;
using (var database = new DatabaseContext())
{
CallForPapers = database.CallsForPapers.FirstOrDefault(t => t.Id == CallForPapersId);
}
string path = saveFile();
if (path != null)
{
Paper paper = new Paper(CallForPapers, path);
try
{
service.Add(paper);
Status = true;
}
catch (Exception)
{
Status = false;
Message = "An error occured while adding the paper";
throw;
}
}
}
public async Task <IHttpActionResult> Post(EntityAddOrUpdateViewModel model)
{
IHttpActionResult res = BadRequest();
if (!ModelState.IsValid)
{
return(res);
}
var serviceRes = await _entityService.Add(new EntityAddRequest()
{
RequestOwner = User,
ViewModel = model
});
if (serviceRes.Access == ResponseAccess.Granted)
{
res = Ok(model);
}
if (serviceRes.Access == ResponseAccess.Deny)
{
res = Unauthorized(serviceRes.Message);
}
return(res);
}
public bool CheckEntity(IEntityService <CallForPapers> service, CallForPapers entity)
{
try
{
entity = service.Add(entity);
}
catch
{
throw;
}
return(true);
}
// POST: odata/{controller}
/// <summary>
/// Posts the item by specified object.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
public virtual async Task <IHttpActionResult> Create(TEntity item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_service.Add(item);
await _context.SaveChangesAsync();
return(Created(item));
}
public void Create(Brand brand)
{
using (var transaction = _brandRepository.BeginTransaction())
{
_brandRepository.Add(brand);
_brandRepository.SaveChange();
_entityService.Add(brand.Name, brand.SeoTitle, brand.Id, BrandEntityTypeId);
_brandRepository.SaveChange();
transaction.Commit();
}
}
public bool CheckEntity(IEntityService <Conference> service, Conference entity)
{
try
{
entity = service.Add(entity);
}
catch
{
throw;
}
return(true);
}
public void Create(Category category)
{
using (var transaction = _categoryRepository.BeginTransaction())
{
_categoryRepository.Add(category);
_categoryRepository.SaveChange();
_entityService.Add(category.Name, category.SeoTitle, category.Id, CategoryEntityTypeId);
_categoryRepository.SaveChange();
transaction.Commit();
}
}
public async Task <IHttpActionResult> PostAddress(Address address)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//_context.Addresses.Add(address);
_serviceProxy.Add(address);
await _context.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = address.Id }, address));
}
public void Create(Page page)
{
using (var transaction = _pageRepository.BeginTransaction())
{
_pageRepository.Add(page);
_pageRepository.SaveChange();
_entityService.Add(page.Name, page.SeoTitle, page.Id, PageEntityTypeId);
_pageRepository.SaveChange();
transaction.Commit();
}
}
public async Task Create(Page page)
{
using (var transaction = _pageRepository.BeginTransaction())
{
page.Slug = _entityService.ToSafeSlug(page.Slug, page.Id, PageEntityTypeId);
_pageRepository.Add(page);
await _pageRepository.SaveChangesAsync();
_entityService.Add(page.Name, page.Slug, page.Id, PageEntityTypeId);
await _pageRepository.SaveChangesAsync();
transaction.Commit();
}
}
public async Task Create(Vendor vendor)
{
using (var transaction = _vendorRepository.BeginTransaction())
{
vendor.Slug = _entityService.ToSafeSlug(vendor.Slug, vendor.Id, VendorEntityTypeId);
_vendorRepository.Add(vendor);
await _vendorRepository.SaveChangesAsync();
_entityService.Add(vendor.Name, vendor.Slug, vendor.Id, VendorEntityTypeId);
await _vendorRepository.SaveChangesAsync();
transaction.Commit();
}
}
public async Task Create(Brand brand)
{
using (var transaction = _brandRepository.BeginTransaction())
{
brand.Slug = _entityService.ToSafeSlug(brand.Slug, brand.Id, BrandEntityTypeId);
_brandRepository.Add(brand);
await _brandRepository.SaveChangesAsync();
_entityService.Add(brand.Name, brand.Slug, brand.Id, BrandEntityTypeId);
await _brandRepository.SaveChangesAsync();
transaction.Commit();
}
}
public async Task Create(Category category)
{
using (var transaction = _categoryRepository.BeginTransaction())
{
category.Slug = _entityService.ToSafeSlug(category.Slug, category.Id, CategoryEntityTypeId);
_categoryRepository.Add(category);
await _categoryRepository.SaveChangesAsync();
_entityService.Add(category.Name, category.Slug, category.Id, CategoryEntityTypeId);
await _categoryRepository.SaveChangesAsync();
transaction.Commit();
}
}
public void Create(Vendor vendor)
{
using (var transaction = _vendorRepository.BeginTransaction())
{
vendor.SeoTitle = _entityService.ToSafeSlug(vendor.SeoTitle, vendor.Id, VendorEntityTypeId);
_vendorRepository.Add(vendor);
_vendorRepository.SaveChanges();
_entityService.Add(vendor.Name, vendor.SeoTitle, vendor.Id, VendorEntityTypeId);
_vendorRepository.SaveChanges();
transaction.Commit();
}
}
public HttpResponseMessage CreateNewGame([FromBody] Game game)
{
var userId = HttpContext.Current.User.Identity.GetUserId <int>();
var newGame = new Game()
{
Name = game.Name,
Description = game.Description,
GameSystem = game.GameSystem,
GameSessions = new List <GameSession>(),
};
gameEntityService.Add(newGame);
return(Request.CreateResponse(HttpStatusCode.OK, newGame));
}
public ActionResult AddConfirmed(EntidadViewModel model, IEntityService entityService)
{
var entidad = new entidad()
{
Nombre = model.Name,
Apellidos = model.LastName,
CodId = model.CodId,
IdPais = 1,
Direccion = "dkd",
IdAdminPropiedades = 1,
UserCreated = 1,
DateCreated = DateTime.Now
};
entityService.Add(entidad);
return(RedirectToAction("Index"));
}
public void Create(NewsItem newsItem)
{
if (newsItem != null)
{
using (var transaction = _newsItemRepository.BeginTransaction())
{
newsItem.SeoTitle = _entityService.ToSafeSlug(newsItem.SeoTitle, newsItem.Id, NewsItemEntityTypeId);
_newsItemRepository.Add(newsItem);
_newsItemRepository.SaveChange();
_entityService.Add(newsItem.Name, newsItem.SeoTitle, newsItem.Id, NewsItemEntityTypeId);
_newsItemRepository.SaveChange();
transaction.Commit();
}
}
}
public virtual ActionResult <TEntityResponse> Post([FromBody] TEntityRequest resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(Errors(resource)));
}
var mapped = Mapper.Map <TEntity>(resource);
var entity = Service.Add(mapped);
if (Notificator.HasErrors())
{
return(BadRequest(Errors(resource)));
}
return(Created(string.Empty, Mapper.Map <TEntityResponse>(entity)));
}
public HttpResponseMessage CreateNewGameSession([FromBody] GameSession gameSession)
{
var userId = HttpContext.Current.User.Identity.GetUserId <int>();
var newGameSession = new GameSession()
{
Name = gameSession.Name,
Description = gameSession.Description,
GameId = gameSession.GameId,
Game = gameEntityService.GetById(gameSession.GameId),
GameSessionState = GameSessionState.InLobby,
GameSessionSlots = new List <GameSessionSlot>(),
MaximumPlayers = gameSession.MaximumPlayers
};
gameSessionEntityService.Add(newGameSession);
return(Request.CreateResponse(HttpStatusCode.OK, newGameSession));
}
// POST: api/DateRages
public IHttpActionResult Post([FromBody] DateRangeDTO value)
{
IHttpActionResult response;
LogDTO log = new LogDTO()
{
Date = DateTime.Now,
Request = Request.RequestUri.PathAndQuery,
RequestMethod = "POST"
};
try
{
if (value.Id == 0)
{
var data = dateRangeDTOService.Add(value);
response = Created("database", value);
log.ResponseDataCount = 1;
log.ResponseStatus = (int)HttpStatusCode.Created;
}
else
{
dateRangeDTOService.Update(value);
response = Ok(value);
log.ResponseStatus = (int)HttpStatusCode.OK;
}
dateRangeDTOService.Save();
}
catch (Exception ex)
{
response = BadRequest(ex.Message);
log.ResponseStatus = (int)HttpStatusCode.BadRequest;
}
logDTOService.Add(log);
logDTOService.Save();
return(response);
}
public async Task <IActionResult> Post([FromBody] TViewModel view, CancellationToken cancellationToken = default)
{
var result = new Result <TViewModel>();
try
{
var entity = mapper.Map <TViewModel, TEntity>(view);
await entityService.Add(entity, cancellationToken);
result.Item = mapper.Map <TEntity, TViewModel>(entity);
return(Ok(result));
}
catch (Exception ex)
{
result.AddError(ex.Message);
return(BadRequest(result));
}
}
public ActionResult Create(ProductView pv)
{
if (ModelState.IsValid)
{
Product productToAdd = AutoMapperHelper.Get <ProductView, Product>(pv);
if (pv.CategoryId.HasValue)
{
var categoryLinked = categoryService.GetById(pv.CategoryId.Value);
categoryLinked.Products.Add(productToAdd);
categoryService.save(categoryLinked);
}
else
{
var newlyProduct = service.Add(productToAdd);
}
return(RedirectToAction("Index"));
}
return(GetFormView(pv, FormTitle: "Add New Product", FormAction: "Create", FormActionHeading: "Add NewProduct", FormSubmitText: "Save New Product"));
}
public HttpResponseMessage CreateNewCharacter([FromBody] Character character)
{
var userId = HttpContext.Current.User.Identity.GetUserId <int>();
var newCharacter = new Character()
{
Name = character.Name,
Gender = character.Gender,
Statistics = new List <CharacterStatistic>()
};
foreach (var stat in character.Statistics)
{
var characterStat = new CharacterStatistic(character.Id, stat.Id)
{
CurrentValue = stat.CurrentValue,
};
newCharacter.Statistics.Add(characterStat);
}
characterEntityService.Add(newCharacter);
return(Request.CreateResponse(HttpStatusCode.OK, newCharacter));
}
public ActionResult Add([FromBody] EntityRequest entity)
{
var response = new Response <object>();
try
{
if (_entityService.Add(entity))
{
response.Result = 1;
response.Message = "Entidad registrado correctamente.";
}
else
{
response.Message = "No se pudo registrado la entidad.";
}
return(Ok(response));
}
catch (Exception ex)
{
response.Message = ex.Message;
return(Ok(response));
}
}
public void Execute(CreateClientCommandContext commandContext)
{
_entityService.Add(new Client(commandContext.Form.Name, commandContext.Form.Inn));
}
