private static ItemDto CreateQuestion(ItemDefinition itemDefinition, AssessmentInstance assessmentInstance)
{
var itemInstance =
assessmentInstance.ItemInstances.FirstOrDefault(
i => i.ItemDefinitionCode == itemDefinition.CodedConcept.Code);
var item = new ItemDto
{
Metadata = itemDefinition.ItemMetadata,
Key = assessmentInstance.Key,
ItemDefinitionCode = itemDefinition.CodedConcept.Code,
ItemDefinitionName = itemDefinition.CodedConcept.Name,
Options = Mapper.Map <IEnumerable <Lookup>, IEnumerable <LookupDto> > (itemDefinition.Options),
ItemType = itemDefinition.ItemType.CodedConcept.Code
};
if (itemInstance == null || itemInstance.Value == null)
{
item.Value = null;
}
else if (itemInstance.Value is Lookup)
{
item.Value = Mapper.Map <Lookup, LookupDto> (itemInstance.Value as Lookup);
}
else if (itemInstance.Value is IEnumerable && !(itemInstance.Value is string))
{
item.Value = Mapper.Map(itemInstance.Value, itemInstance.Value.GetType(), typeof(IEnumerable <LookupDto>));
}
else
{
item.Value = itemInstance.Value;
}
return(item);
}
private static void MapItems(IContainItems itemContainer, IContainItemDefinitions itemDefinitionContainer, AssessmentInstance assessmentInstance)
{
foreach (var itemDefinition in itemDefinitionContainer.ItemDefinitions)
{
if (itemDefinition.ItemType == ItemType.Question)
{
itemContainer.Items.Add(CreateQuestion(itemDefinition, assessmentInstance));
}
else if (itemDefinition.ItemType == ItemType.Group || itemDefinition.ItemType == ItemType.Section)
{
var groupItemDto = new ItemDto
{
Metadata = itemDefinition.ItemMetadata,
Key = assessmentInstance.Key,
ItemDefinitionCode = itemDefinition.CodedConcept.Code,
ItemDefinitionName = itemDefinition.CodedConcept.Name,
Items = new List <ItemDto> (),
ItemType = itemDefinition.ItemType.CodedConcept.Code
};
MapItems(groupItemDto, itemDefinition, assessmentInstance);
itemContainer.Items.Add(groupItemDto);
}
}
}
private List <ItemDto> CreateItem(List <ParagraphContent> content)
{
var seek = 0;
List <ItemDto> items = new List <ItemDto>();
foreach (var p in content)
{
ParNode node = null;
var ParagraphId = new ItemDto();
foreach (var item in p.Content)
{
var i = new ItemDto();
node = new ParNode(item.Key, node);
i.TextContent = item.Value;
i.Number = node.Number;
if (node.Parent.CurrentParentNode < 0)
{
node.Parent.Seek = seek;
i.ParentId = null;
i.IsRoot = true;
ParagraphId = i;
}
else
{
i.ParagraphId = ParagraphId;
i.ParentId = items[node.Parent.CurrentParentNode + seek];
i.IsRoot = false;
}
items.Add(i);
}
seek += p.Content.Count;
}
return(items);
}
public StatusCodeResult Post([FromBody] ItemDto itemDto)
{
try
{
var itemType = _itemTypeRepository.Get(itemDto.ItemTypeCode);
if (itemType != null)
{
var item = new Item(
code: itemDto.Code,
price: new Money(itemDto.Price),
itemType: itemType
);
_itemRepository.Save(item);
return(new OkResult());
}
return(new NotFoundResult());
}
catch (Exception)
{
return(new StatusCodeResult((int)HttpStatusCode.InternalServerError));
}
}
public ItemResponse CreateItemResponse(ItemDto item) => new ItemResponse
{
Status = true,
StatusText = "Item successfully created!",
StatusCode = 201,
Item = item
};
public async Task Create_SuccessStatusCode_Creates()
{
var Item = new ItemDto()
{
Id = new Guid("d8b66e56-7a21-4166-98ac-ecefc3040a7f"),
Name = "New Item",
};
using var client = (await CreateHost()).GetTestClient();
var requestContent = new StringContent(
JsonConvert.SerializeObject(Item),
Encoding.UTF8,
"application/json"
);
var response = await client.PostAsync(Post.CreateItem, requestContent);
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <Guid>(content);
Assert.NotEqual(Guid.Empty, result);
}
public BaseResponse UpdateItem(string userId, ItemDto itemDto)
{
try
{
userId.ThrowIfNullOrEmpty();
itemDto.ThrowIfNull();
var itemToUpdate = _itemsRepository.All()
.FirstOrDefault(x => x.Id == itemDto.Id && x.UserId == userId);
itemToUpdate.ThrowIfNullWithShowMessage($"Current user does not have item with id {itemDto.Id}");
itemToUpdate.Name = itemDto.Name;
itemToUpdate.ReplenishmentPeriod = itemDto.ReplenishmentPeriod;
itemToUpdate.NextReplenishmentDate = itemDto.NextReplenishmentDate;
itemToUpdate.UserId = userId;
_itemsRepository.Update(itemToUpdate);
_itemsRepository.SaveChanges();
var response = ResponseBuilder.Success();
return(response);
}
catch (ShowErrorMessageException ex)
{
var response = ResponseBuilder.Failure <ItemDto>(ex.Message);
return(response);
}
catch (Exception ex)
{
var response = ResponseBuilder.Failure("An error occurred while updating item");
return(response);
}
}
public IActionResult UpdateItem([FromBody] ItemDto itemDto)
{
if (itemDto == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var getItemResponse = _itemsDataService.GetItem(itemDto.Id, UserId);
if (!getItemResponse.IsSuccess || getItemResponse.Data == null)
{
return(BadRequest(getItemResponse));
}
var updateResponse = _itemsDataService.UpdateItem(this.UserId, itemDto);
if (!updateResponse.IsSuccess)
{
return(BadRequest(updateResponse));
}
return(Ok(updateResponse));
}
public ItemResponse SingleItemResponse(ItemDto item) => new ItemResponse
{
Status = true,
StatusCode = 200,
StatusText = "Successfully retrieved item!",
Item = item
};
public void UpdateItem(ItemDto item, Boolean increase)
{
var index = Items.IndexOf(item);
var category = Categories.Where(i => i.Id == item.CategoryId).FirstOrDefault();
Items[index] = item;
Items[index].Category = category;
if (increase)
{
if (item.PackedCount < item.Count)
{
item.PackedCount++;
total_packed++;
item.Completed = item.PackedCount >= item.Count;
if (item.Completed && CompletedFilter)
{
Items.Remove(item);
}
ApiMethods.UpdateItem(item);
}
}
else
{
if (item.PackedCount > 0)
{
item.PackedCount--;
total_packed--;
item.Completed = item.PackedCount >= item.Count;
ApiMethods.UpdateItem(item);
}
}
}
public static void UpdateItem(ItemDto itemDto)
{
ValidateItemDto(itemDto);
var item = GetItem(itemDto.ItemCode);
item.Name = itemDto.Name;
item.Description = itemDto.Description;
}
public async Task <ActionResult> Buy(ItemDto item)
{
var characterId = Guid.Parse(User.Identity.Name);
var res = await CharacterFacade.BuyItemAsync(characterId, item);
return(RedirectToAction("Index"));
}
public void Store(ItemDto item)
{
using (var session = _store.OpenSession())
{
session.Store(item);
session.SaveChanges();
}
}
public async Task Assign(QuestDto quest, MonsterDto monster, ItemDto item)
{
var q = Mapper.Map <QuestEditDto>(quest);
q.MonsterId = monster.Id;
q.ItemId = item.Id;
await Update(q);
}
async Task IItemService.UpdateAsync(int id, ItemDto item)
{
var json = JsonSerializer.Serialize(item);
var data = new StringContent(json, Encoding.UTF8, "application/json");
var response = await Client.PutAsync($"{_itemsRequestUri}/{id}", data).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
}
private ItemEquipmentSet MapSet(ItemDto input)
{
return(new ItemEquipmentSet
{
Name = input.SetName,
ItemIds = MapItemPaths(input.SetItems)
});
}
public static void DeleteItem(ItemDto itemDto)
{
ValidateItemDto(itemDto);
var item = DBManager.itemRepo[itemDto.ItemCode];
item.Archive();
}
public async Task DeleteItem(ItemDto itemRequest)
{
if (_connection.State.Equals(HubConnectionState.Connected))
{
Debug.WriteLine("Sending to server about item deleted:" + itemRequest.Id);
await SendAsync("DeleteItem", itemRequest);
}
}
public IHttpActionResult InsertData([FromBody] ItemDto oneItem)
{
if (oneItem == null)
{
return(BadRequest("Provided data is invalid."));
}
return(Ok(service.InsertData(oneItem)));
}
public void Put(int id, [FromBody] ItemDto itemDto)
{
Item itemToUpdate = _mapper.Map <Item>(itemDto);
itemToUpdate.Id = id;
_context.Items.Update(itemToUpdate);
_context.SaveChanges();
}
public SiteUrl TrackBack(ItemDto item)
{
return(new SiteUrl(this.Domain, this.HttpPort, false, null, "Services", "Trackback", null, new Dictionary <string, string>
{
{ "id", item.Id.ToString(CultureInfo.InvariantCulture) },
{ "itemType", "Post" }
}));
}
/*
* public TestItemService(DbSessionFixture fixture) : base(fixture)
* {
* }*/
//[Fact]
public void Can_Remove_Existing_Item_In_Service()
{
var prop = _Items[0];
IItemService service = new ItemService(new ItemRepository());
ItemDto actual = null;// service.GetItem(prop.Id);
Assert.Equal("1", actual.Code);
}
public void ValidateItemNames_Success(string value)
{
var validateItemNamesProcessor = new ValidateItemNames();
var importItem = new ItemDto(value);
validateItemNamesProcessor.ValidateName(importItem);
Assert.Empty(validateItemNamesProcessor.Errors);
}
public static Item MapToItem(this ItemDto itemDto) => itemDto == null
? null
: new Item
{
Id = itemDto.Id,
Description = itemDto.Description,
Price = new Money(itemDto.Price, itemDto.Currency)
};
public static Item MapToItem(this ItemDto itemDto, Item dbItem)
{
dbItem.Id = itemDto.Id;
dbItem.Description = itemDto.Description;
dbItem.Price.Currency = itemDto.Currency;
dbItem.Price.Value = itemDto.Price;
return(dbItem);
}
internal Item MapToEntity(ItemDto item)
{
return(new Item()
{
Id = item.Id,
Name = item.Name,
});
}
public Guid Add(ItemDto itemDto)
{
itemDto.Id = Guid.NewGuid();
repository.Insert(itemDto.MapToItem());
repository.SaveChanges();
return(itemDto.Id);
}
public IHttpActionResult UpdateData([FromBody] ItemDto oneItem)
{
if (oneItem == null || oneItem.ItemID == 0 || oneItem.ItemID < 0)
{
return(BadRequest("Provided data is invalid."));
}
return(Ok(service.UpdateData(oneItem)));
}
public SiteUrl Delete(ItemDto item)
{
string[] segments = item == null ? null : new[]
{
item.Id.ToString(CultureInfo.InvariantCulture)
};
return(new SiteUrl(this.Domain, this.HttpPort, false, "Dxt-Admin", "Post", "ConfirmDelete", segments, null));
}
public ItemDto SaveItem(ItemDto item)
{
var entity = item.Adapt <Item>();
var result = _dbClient.Create(entity);
_eventPublisher.Publish(entity);
return(result.Adapt <ItemDto>());
}
// WHERE F.{0}ItemId{1} = I.{0}ID{1}\r\n AND F.{0}FieldId{1} = {2}fieldID{3}\r\n AND F.{0}Value{1} = {2}fieldValue{3}\r\n
// ORDER BY I.{0}Name{1}, F.{0}Language{1}, F.{0}Version{1}", (object) "fieldID", (object) FieldIDs.WorkflowState,
// (object) "fieldValue", (object) info.StateID)
var query = Query.EQ("WorkflowStateId", workflowStateId);
return Items.Find(query);
}
public bool DeleteItem(Guid id)
{
var result = Items.Remove(Query.EQ("_id", id), RemoveFlags.Single, SafeMode);
return result != null && result.Ok;
}
public void Store(ItemDto item)
{
Items.Save(item, SafeMode);
}
public void Store(ItemDto item)
{
_items.Save(item);
}
public void Store(ItemDto item)
{
using (var session = _store.OpenSession())
{
session.Store(item);
session.SaveChanges();
}
}
public void Store(ItemDto itemDto)
{
throw new NotImplementedException();
}
public void Test2()
{
var system = new SolarSystemDto { Id = 1, Name = "SystemName" };
var shipItem = new ItemDto { Id = 1, Name = "VictimShip" };
Save(system);
Save(shipItem);
var kill = new ParsedKillResult {
Header = new ParsedKillHeader {
AllianceName = "VictimAlliance",
CorporationName = "VictimCorp",
DamageTaken = 100,
FactionName = "FactionName",
ShipName = shipItem.Name,
SystemName = system.Name,
SystemSecurity = 9000,
Timestamp = DateTime.Now,
VictimName = "VictimPilot"
}
};
var ks = Resolve<IKillService>();
ks.CreateKill(kill);
kill.Header.AllianceName = "SecondAlliance";
kill.Header.VictimName = "VictimPilot";
ks.CreateKill(kill);
}
public void Store(ItemDto item)
{
using (var session = _store.OpenSession())
{
//using (session.Advanced.DocumentStore.DisableAggressiveCaching())
{
session.Store(item);
session.SaveChanges();
}
}
}
/// <summary>
/// checks a series of parent items
/// </summary>
/// <param name="item"></param>
/// <param name="parentKeys"></param>
/// <returns></returns>
public bool CheckParent(ItemDto item, IEnumerable<string> parentKeys)
{
//catch the sitecore root item
if (item.ParentId == Guid.Empty) return true;
var parent = GetItem(item.ParentId);
if (parent.Key == CleanKey(parentKeys.First()))
{
return CheckParent(parent, parentKeys.Skip(1));
}
else return false;
}
