public HttpResponseMessage CreateItem(string ticket, Item item)
{
var securityProvider = new SecurityProvider(_connectionString);
var sessionInfo = securityProvider.GetSessionInfo(ticket);
if (sessionInfo == null)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
var createRequest = new CreateItemRequest
{
Item = item,
UserId = sessionInfo.User.Id
};
var handler = new CreateItemHandler(_connectionString);
var response = handler.Handle(createRequest);
var httpStatusCode = ResolveStatusCode(response);
return(Request.CreateResponse(httpStatusCode, response));
}
public async Task <CreateItemResponse> Post([FromBody] CreateItemRequest request)
{
CreateItemResponse createItemResponse = null;
var pattern = @"^(?:\d{12})$";
try
{
if (!Regex.IsMatch(request.UPC, pattern))
{
throw new Exception("UPC must be 12 digit number.");
}
var item = await _domainService.CreateItem(request);
if (item != null)
{
createItemResponse = _mapper.Map <CreateItemResponse>(item);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(createItemResponse);
}
public CreateItemResponse CreateItem(CreateItemRequest request)
{
CreateItemResponse response = new CreateItemResponse();
if (string.IsNullOrEmpty(request.ItemEntity.Name))
{
response.AddError("İsim boş olamaz!");
}
if (context.Items.Any(q => q.Name == request.ItemEntity.Name))
{
response.AddError(Resources.ItemNameExists);
}
if (response.IsSuccessful)
{
Item item = CreateNewAuditableObject(request);
item.Name = request.ItemEntity.Name;
item.Description = request.ItemEntity.Description;
context.Items.Add(item);
context.SaveChanges();
response.ItemEntity = ConvertDboToEntity(item);
}
return(response);
}
public async Task CreateItem_Ok(string relativeRef)
{
// Arrange
var data = new CreateItemRequest
{
Item = new Item
{
Name = "Hallo1",
},
MyItems = new List <Item>
{
new Item
{
Name = "Hallo11",
},
new Item
{
Name = "Hallo21",
},
new Item
{
Name = "Hallo31",
},
},
};
// Act
var response = await HttpClient.PostAsync(relativeRef, ToJson(data));
// Assert
response.Should().NotBeNull();
response.StatusCode.Should().Be(HttpStatusCode.OK);
}
public CreateItemResponse Handle(CreateItemRequest request) // TODO NEEDS WORK
{
var response = new CreateItemResponse();
response.Errors = Validate(request);
if (response.HasErrors)
{
return(response);
}
try
{
var now = DateTime.Now;
request.Item.IsActive = true;
request.Item.UserNotified = false;
request.Item.NotifyByEmail = true;
request.Item.Created = now;
request.Item.Modified = now;
request.Item.LastChecked = now.AddDays(-30);
request.Item.Content = "";
_itemRepository.Create(request.Item);
response.Success = true;
return(response);
}
catch (Exception)
{
response.Errors.Add(new ErrorStatus("BAD_REQUEST"));
return(response);
}
}
public async Task <CreatedActionResult <ItemResponse> > PostAddItemToCharacterInventoryAsync(
[FromServices] NaheulbookExecutionContext executionContext,
[FromRoute] int characterId,
CreateItemRequest request
)
{
try
{
var item = await _characterService.AddItemToCharacterAsync(executionContext, characterId, request);
return(_mapper.Map <ItemResponse>(item));
}
catch (ForbiddenAccessException ex)
{
throw new HttpErrorException(StatusCodes.Status403Forbidden, ex);
}
catch (CharacterNotFoundException ex)
{
throw new HttpErrorException(StatusCodes.Status404NotFound, ex);
}
catch (ItemTemplateNotFoundException ex)
{
throw new HttpErrorException(StatusCodes.Status400BadRequest, ex);
}
}
public static string createItem(AuthenticationData authData, MTOMAttachment[] attachments, string documentClass, string documentType, string employeeId, string firstName, string lastName)
{
CreateItemRequest request = new CreateItemRequest();
request.AuthenticationData = authData;
request.Item = new CreateItemRequestItem();
request.Item.ItemXML = XmlUtil.createItem(documentClass, documentType, employeeId, firstName, lastName);
// Add mtom attachments
if (attachments != null)
{
request.mtomRef = new MTOMAttachment[attachments.Length];
for (int i = 0; i < attachments.Length; i++)
{
request.mtomRef[i] = attachments[i];
}
}
CreateItemReply reply = client.CreateItem(request);
if (reply.RequestStatus.success == true)
{
return(reply.Item.URI);
}
else
{
Log.Error("CreateItem Failed");
return(null);
}
}
public async Task <ActionResult <Item> > PostItem(CreateItemRequest request)
{
try
{
var itemList = await _context.ItemLists.Where(il => il.AccessCode == request.ListAccessCode).FirstAsync();
if (!itemList.IsPublic && itemList.ListPassword != request.ListPassword)
{
return(BadRequest("Wrong list password"));
}
var item = new Item
{
Name = request.Name,
ListId = itemList.Id
};
_context.Items.Add(item);
await _context.SaveChangesAsync();
return(Ok(new SuccessfulItemCreationResponse()
{
ItemId = item.Id,
ItemName = request.Name,
ListName = itemList.Name
}));
}
catch {
return(BadRequest("Proper list access code needed"));
}
}
public async Task Handle_ShouldReturnItem_WhenValid()
{
var expectedId = Guid.NewGuid();
var mapper = new Mock <IMapper>();
mapper
.Setup(m => m.Map <Item>(It.IsAny <Models.Domain.Item>()))
.Returns(new Item {
Id = expectedId
});
var store = new Mock <IBasketStore>();
store
.Setup(s => s.GetById(It.IsAny <Guid>()))
.Returns(new Models.Domain.Basket());
var handler = new CreateItemRequestHandler(mapper.Object, store.Object);
var request = new CreateItemRequest()
{
BasketId = Guid.NewGuid(), Item = new Models.Request.PostItem()
};
var item = await handler.Handle(request);
Assert.Equal(expectedId, item.Id);
}
public async Task AddItemToAsync_ShouldCreateAnItemInDatabase_ThenReturnsAFullyLoadedItem()
{
const int itemId = 25;
const int characterId = 10;
var itemTemplateId = Guid.NewGuid();
var itemData = new ItemData();
var itemTemplate = new ItemTemplate();
var request = new CreateItemRequest {
ItemData = itemData, ItemTemplateId = itemTemplateId
};
var createdItem = new Item {
Id = itemId
};
var fullyLoadedItem = new Item();
_unitOfWorkFactory.GetUnitOfWork().ItemTemplates.GetAsync(itemTemplateId)
.Returns(itemTemplate);
_itemFactory.CreateItem(ItemOwnerType.Character, characterId, itemTemplate, itemData)
.Returns(createdItem);
_unitOfWorkFactory.GetUnitOfWork().Items.GetWithAllDataAsync(itemId)
.Returns(fullyLoadedItem);
var actualItem = await _service.AddItemToAsync(ItemOwnerType.Character, characterId, request);
Received.InOrder(() =>
{
_unitOfWorkFactory.GetUnitOfWork().Items.Add(createdItem);
_unitOfWorkFactory.GetUnitOfWork().SaveChangesAsync();
});
actualItem.Should().BeSameAs(fullyLoadedItem);
}
public void Test_Create_Item()
{
List <DashBoard> listas = new List <DashBoard>();
listas.Add(new DashBoard
{
Id = 5
});
var request = new CreateItemRequest
{
DashId = 5,
Item =
{
CheckInterval = 5000,
Content = "string",
Created = DateTime.Now,
CSS = "string",
DashBoardId = 5,
Failed = 0,
Id = 5,
IsActive = true,
LastChecked = DateTime.Now.AddDays(-1),
Modified = DateTime.Now
}
};
var handler = new CreateItemHandler("SSSS");
handler.Handle(request);
//act
}
public async Task <ServiceResult <CreateItemResponse> > CreateItemAsync(CreateItemRequest request, ClaimsPrincipal authenticatedUser)
{
ServiceResult <CreateItemResponse> errorResult = new ServiceResult <CreateItemResponse>(HttpStatusCode.BadRequest);
if (request == null)
{
return(errorResult);
}
DateTime utcNow = DateTime.UtcNow;
ItemEntity itemEntity = new ItemEntity
{
// Add auto Generated ID
Name = request.Name,
Price = request.Price,
CreatedOn = utcNow,
IsDeleted = false,
};
await _itemRepository.CreateAsync(itemEntity);
return(new ServiceResult <CreateItemResponse>(new CreateItemResponse()));
}
private async static Task CreateItem(DocumentServiceDefinition.DocumentServiceDefinitionClient documentClient)
{
var input = new CreateItemRequest {
Name = "ChildOfRoot", TypeId = 1, ProjectId = 1, ParentId = 9
};
var reply = await documentClient.CreateItemAsync(input);
}
/// <summary>
/// Creates the item.
/// </summary>
/// <param name="createItemRequest">The folder.</param>
/// <param name="db">The database.</param>
public void CreateItem(CreateItemRequest createItemRequest, string db)
{
this.SetDatabase(db);
var targetItem = database.GetItem(createItemRequest.TargetPath);
targetItem.Add(createItemRequest.Name, new TemplateID(new ID(createItemRequest.TemplateId)));
}
public void Put(string remotename, System.IO.Stream stream)
{
EnforceConsistencyDelay(RemoteOperation.Put);
var overwrite = FileCache.ContainsKey(remotename);
var fileid = overwrite ? m_filecache[remotename] : null;
var url = string.Format(overwrite ? "{0}/nodes/{1}/content?suppress=deduplication" : "{0}/nodes?suppress=deduplication", ContentUrl, fileid);
var createreq = new CreateItemRequest()
{
Name = remotename,
Kind = CONTENT_KIND_FILE,
Labels = m_labels,
Parents = new string[] { CurrentDirectory.ID }
};
try
{
var item = m_oauth.PostMultipartAndGetJSONData <ResourceModel>(
url,
req =>
{
req.Method = overwrite ? "PUT" : "POST";
},
new MultipartItem(createreq, name: "metadata"),
new MultipartItem(stream, name: "content", filename: remotename)
);
if (m_filecache != null)
{
m_filecache[item.Name] = item.ID;
}
}
catch (Exception ex)
{
#if DEBUG
if (ex is WebException)
{
using (var sr = new StreamReader((ex as WebException).Response.GetResponseStream()))
Console.WriteLine(sr.ReadToEnd());
}
#endif
m_filecache = null;
throw;
}
finally
{
m_waitUntil = DateTime.Now + m_delayTimeSpan;
}
}
private void HandleCreateItem(CreateItemRequest request)
{
var id = cache
.Select(x => x.Key)
.LastOrDefault() + 1;
var eTag = ComputeETag(request.Code, request.Description, request.Value);
cache.Add(id, eTag);
store.Tell(new StoreItem(id, request.Code, request.Description, request.Value, eTag));
Sender.Tell(new CreateItemResponse(id, eTag));
}
public async Task PutAsync(string remotename, Stream stream, CancellationToken cancelToken)
{
EnforceConsistencyDelay(remotename);
var overwrite = FileCache.ContainsKey(remotename);
var fileid = overwrite ? m_filecache[remotename] : null;
var url = string.Format(overwrite ? "{0}/nodes/{1}/content?suppress=deduplication" : "{0}/nodes?suppress=deduplication", ContentUrl, fileid);
var createreq = new CreateItemRequest()
{
Name = remotename,
Kind = CONTENT_KIND_FILE,
Labels = m_labels,
Parents = new string[] { CurrentDirectory.ID }
};
try
{
var item = await m_oauth.PostMultipartAndGetJSONDataAsync <ResourceModel>(
url,
req =>
{
req.Method = overwrite ? "PUT" : "POST";
},
cancelToken,
new MultipartItem(createreq, "metadata"),
new MultipartItem(stream, "content", remotename)
).ConfigureAwait(false);
if (m_filecache != null)
{
m_filecache[item.Name] = item.ID;
}
}
catch (Exception ex)
{
#if DEBUG
if (ex is WebException exception)
{
using (var sr = new StreamReader(exception.Response.GetResponseStream()))
Console.WriteLine(sr.ReadToEnd());
}
#endif
m_filecache = null;
throw;
}
finally
{
SetWaitUntil(remotename, DateTime.Now + m_delayTimeSpan);
}
}
public void PostAddItemToCharacterInventory_ShouldReturnExpectedHttpStatusCodeOnKnownErrors(Exception exception, int expectedStatusCode)
{
const int characterId = 2;
var request = new CreateItemRequest();
_characterService.AddItemToCharacterAsync(Arg.Any <NaheulbookExecutionContext>(), Arg.Any <int>(), Arg.Any <CreateItemRequest>())
.Returns(Task.FromException <Item>(exception));
Func <Task> act = () => _controller.PostAddItemToCharacterInventoryAsync(_executionContext, characterId, request);
act.Should().Throw <HttpErrorException>().Which.StatusCode.Should().Be(expectedStatusCode);
}
public void PostAddItemToCharacterInventory_WhenCatchItemTemplateNotFound_Return400()
{
const int characterId = 2;
var itemTemplateId = Guid.NewGuid();
var request = new CreateItemRequest();
_characterService.AddItemToCharacterAsync(Arg.Any <NaheulbookExecutionContext>(), Arg.Any <int>(), Arg.Any <CreateItemRequest>())
.Returns(Task.FromException <Item>(new ItemTemplateNotFoundException(itemTemplateId)));
Func <Task> act = () => _controller.PostAddItemToCharacterInventoryAsync(_executionContext, characterId, request);
act.Should().Throw <HttpErrorException>().Which.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
}
public async Task <IActionResult> AddItem([FromBody] CreateItemRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Select(x => x.Value.Errors)
.Where(x => x.Count > 0)
.ToList()));
}
var addedItem = await _itemService.AddItemAsync(request);
return(new OkObjectResult(addedItem));
}
public async Task <ItemResponse> AddItemAsync(CreateItemRequest request)
{
var item = new Item()
{
ItemName = request.ItemName,
ItemDescription = request.ItemDescription,
Reviews = new List <Review>()
};
var created = await _itemRepository.AddAsync(item);
return(MapItemToResponse(created));
}
public async Task <IActionResult> CreateSingleItemApi([FromBody] CreateItemRequest request)
{
var res = await _mediator.Send(new CreateItemCommand
{
ItemName = request.ItemName,
ItemType = request.ItemType
});
if (res != null)
{
return(Ok(res));
}
return(StatusCode(400, "Failed to create item"));
}
public async Task <IActionResult> Post([FromRoute] Guid basketId, [FromBody] PostItem requestItem)
{
var request = new CreateItemRequest {
BasketId = basketId, Item = requestItem
};
var item = await _mediator.Send(request);
if (item == null)
{
return(BadRequest());
}
return(CreatedAtAction("Get", new { basketId = basketId, id = item.Id }, item));
}
public async Task Handle_ShouldReturnNull_WhenBasketDoesntExist()
{
var mapper = new Mock <IMapper>();
var store = new Mock <IBasketStore>();
var handler = new CreateItemRequestHandler(mapper.Object, store.Object);
var request = new CreateItemRequest()
{
BasketId = Guid.NewGuid()
};
var item = await handler.Handle(request);
Assert.Null(item);
}
public CreateItemRequest GetFakeCreateItemRequest_UPC_12DigitNumber()
{
var fake = new CreateItemRequest()
{
ItemNumber = 24516,
IdVendor = 1,
UPC = "025698652100",
ItemDescription = "Item1",
MinimumOrderQuantity = 12,
PurchaseUnitOfMeasure = "KG",
ItemCost = 12.34M
};
return(fake);
}
public async Task <ActionResult> CreateItem([FromBody] CreateItemRequest input)
{
var item = _mapper.Map <Item>(input);
item.UserId = HttpContext.GetUserId();
await _itemService.CreateItemAsync(item);
var output = _mapper.Map <ItemResponse>(item);
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUrl = baseUrl + "/" + ApiRoutes.Items.Get.Replace("{id}", item.Id.ToString());
return(Created(locationUrl, output));
}
public async Task <CreateItemResponse> CreateItem(CreateItemRequest request, CancellationToken cancellationToken)
{
var change = new InventoryItemChange
{
UserId = AuthenticatedAppUserId,
Date = DateTimeOffset.Now
};
await _inventoryService.CreateItemAsync(request.Item, change, request.Snapshot, cancellationToken).ConfigureAwait(false);
return(new CreateItemResponse
{
NewItemId = request.Item.Id
});
}
public async Task <IActionResult> CreateNewItem([FromBody] CreateItemRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _service.Create(ItemViewFactory.Create(model));
if (result == null)
{
return(BadRequest());
}
return(Ok(ItemFactory.CreateEntity(result)));
}
public async Task PostAddItemToCharacterInventory_ShouldLoadCharacterFromService_ThenMapItIntoResponse()
{
const int characterId = 2;
var item = new Item();
var itemResponse = new ItemResponse();
var request = new CreateItemRequest();
_characterService.AddItemToCharacterAsync(_executionContext, characterId, request)
.Returns(item);
_mapper.Map <ItemResponse>(item)
.Returns(itemResponse);
var result = await _controller.PostAddItemToCharacterInventoryAsync(_executionContext, characterId, request);
result.Value.Should().BeSameAs(itemResponse);
}
public async Task <HttpResponseMessage> Post(PostModel payload)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
var message = new CreateItemRequest(payload.Code, payload.Description, payload.Value);
var result = await ActorEnvironment.Current.ItemsGateway.Ask <CreateItemResponse>(message);
var response = Request.CreateResponse(HttpStatusCode.Created);
response.Headers.Location = new Uri($"api/items/{result.Id}", UriKind.Relative);
response.Headers.ETag = new EntityTagHeaderValue(string.Concat("\"", result.ETag, "\""));
return(response);
}
public void Put(string remotename, System.IO.Stream stream)
{
m_waitUntil = DateTime.Now + m_delayTimeSpan;
var overwrite = FileCache.ContainsKey(remotename);
var fileid = overwrite ? m_filecache[remotename] : null;
var url = string.Format(overwrite ? "{0}/nodes/{1}/content?suppress=deduplication" : "{0}/nodes?suppress=deduplication", ContentUrl, fileid);
var createreq = new CreateItemRequest() {
Name = remotename,
Kind = CONTENT_KIND_FILE,
Labels = m_labels,
Parents = new string[] { CurrentDirectory.ID }
};
try
{
var item = m_oauth.PostMultipartAndGetJSONData<ResourceModel>(
url,
req =>
{
req.Method = overwrite ? "PUT" : "POST";
},
new MultipartItem(createreq, name: "metadata"),
new MultipartItem(stream, name: "content", filename: remotename)
);
if (m_filecache != null)
m_filecache[item.Name] = item.ID;
}
catch(Exception ex)
{
#if DEBUG
if (ex is WebException)
using(var sr = new StreamReader((ex as WebException).Response.GetResponseStream()))
Console.WriteLine(sr.ReadToEnd());
#endif
m_filecache = null;
throw;
}
}
public void Put(string remotename, System.IO.Stream stream)
{
var createreq = new CreateItemRequest() {
Name = remotename,
Parent = new IDReference() {
ID = CurrentFolder
}
};
if (m_filecache == null)
PagedFileListResponse(CurrentFolder, false);
var existing = m_filecache.ContainsKey(remotename);
try
{
FileEntity res;
if (existing)
{
res = m_oauth.PostMultipartAndGetJSONData<FileList>(
string.Format("{0}/{1}/content", BOX_UPLOAD_URL, m_filecache[remotename]),
new MultipartItem(stream, name: "file", filename: remotename)
).Entries.First();
}
else
{
res = m_oauth.PostMultipartAndGetJSONData<FileList>(
string.Format("{0}/content", BOX_UPLOAD_URL),
new MultipartItem(createreq, name: "attributes"),
new MultipartItem(stream, name: "file", filename: remotename)
).Entries.First();
}
m_filecache[remotename] = res.ID;
}
catch
{
m_filecache = null;
throw;
}
}
/// <remarks/>
public void CreateItemAsync(CreateItemRequest CreateItemRequest, object userState) {
if ((this.CreateItemOperationCompleted == null)) {
this.CreateItemOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCreateItemOperationCompleted);
}
this.InvokeAsync("CreateItem", new object[] {
CreateItemRequest}, this.CreateItemOperationCompleted, userState);
}
/// <remarks/>
public void CreateItemAsync(CreateItemRequest CreateItemRequest) {
this.CreateItemAsync(CreateItemRequest, null);
}
/// <summary>
/// Sends mail through the exchange server.
/// </summary>
/// <param name="Config"> ReviewNotifierConfiguration. </param>
/// <param name="ExchangeItems"> Mail to send. </param>
/// <returns> true if successful. </returns>
private static bool SendExchangeMail(ReviewNotifierConfiguration Config, List<MessageType> ExchangeItems)
{
int maxQuotaNum = Int32.MaxValue;
var binding = (ExchangeServicePortType)new ExchangeServicePortTypeClient(
new BasicHttpBinding("ExchangeServiceBinding")
{
MaxReceivedMessageSize = maxQuotaNum,
MaxBufferSize = maxQuotaNum,
ReaderQuotas = new System.Xml.XmlDictionaryReaderQuotas()
{
MaxArrayLength = maxQuotaNum,
MaxStringContentLength = maxQuotaNum,
MaxNameTableCharCount = maxQuotaNum
}
},
new EndpointAddress(Config.EmailService));
DistinguishedFolderIdType folder = new DistinguishedFolderIdType();
folder.Id = DistinguishedFolderIdNameType.sentitems;
TargetFolderIdType targetFolder = new TargetFolderIdType();
targetFolder.Item = folder;
CreateItemType createItem = new CreateItemType();
createItem.MessageDisposition = MessageDispositionType.SendAndSaveCopy;
createItem.MessageDispositionSpecified = true;
createItem.SavedItemFolderId = targetFolder;
createItem.Items = new NonEmptyArrayOfAllItemsType();
createItem.Items.Items = ExchangeItems.ToArray();
var createReq = new CreateItemRequest() { CreateItem = createItem };
var response = binding.CreateItem(createReq);
bool result = true;
foreach (ResponseMessageType r in response.CreateItemResponse1.ResponseMessages.Items)
{
if (r.ResponseClass != ResponseClassType.Success)
{
Log.Info("Failed to send the message. ");
Log.Info(r.MessageText);
result = false;
}
}
return result;
}
