/// <summary>
/// Builds a condition element from parsed data
/// </summary>
/// <param name="template">Export template to use</param>
/// <param name="parsedData">Parsed data</param>
/// <param name="project">Project</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="flexFieldObject">Flex field object to which the dialog belongs</param>
/// <param name="exportSettings">Export Settings</param>
/// <returns>Condition string</returns>
public override async Task <string> BuildConditionElementFromParsedData(ExportTemplate template, InventoryConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
StyrItem item = await _cachedDbAccess.GetItemById(parsedData.ItemId);
if (item == null)
{
errorCollection.AddDialogItemNotFoundError();
return(string.Empty);
}
ExportObjectData itemExportData = new ExportObjectData();
itemExportData.ExportData.Add(ExportConstants.ExportDataObject, item);
itemExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeItem);
string conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Operator).Replace(template.Code, await ConditionRenderingUtil.GetItemCompareOperatorFromTemplate(_defaultTemplateProvider, project, parsedData.Operator, errorCollection));
conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Quantity).Replace(conditionCode, parsedData.Quantity.ToString());
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_Operator_IsAtLeast_Start, Placeholder_Operator_IsAtLeast_End, parsedData.Operator == InventoryConditionData.CompareOperator_AtLeast);
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_Operator_IsAtMaximum_Start, Placeholder_Operator_IsAtMaximum_End, parsedData.Operator == InventoryConditionData.CompareOperator_AtMaximum);
_itemPlaceholderResolver.SetErrorMessageCollection(errorCollection);
conditionCode = await _itemPlaceholderResolver.FillPlaceholders(conditionCode, itemExportData);
return(conditionCode);
}
/// <summary>
/// Builds the inventory
/// </summary>
/// <param name="itemCode">Code for the items to repeat</param>
/// <param name="npc">Npc</param>
/// <returns>Inventory of the npc</returns>
private string BuildInventory(string itemCode, KortistoNpc npc)
{
if (npc.Inventory == null)
{
return(string.Empty);
}
int itemIndex = 0;
string inventoryCode = string.Empty;
foreach (KortistoInventoryItem curItem in npc.Inventory)
{
string curItemCode = ExportUtil.BuildPlaceholderRegex(Placeholder_CurItem_Index).Replace(itemCode, itemIndex.ToString());
curItemCode = ExportUtil.RenderPlaceholderIfTrue(curItemCode, Placeholder_CurItem_Is_Equipped_Start, Placeholder_CurItem_Is_Equipped_End, curItem.IsEquipped);
curItemCode = ExportUtil.RenderPlaceholderIfTrue(curItemCode, Placeholder_CurItem_Quantity_Not_Equal_One_Start, Placeholder_CurItem_Quantity_Not_Equal_One_End, curItem.Quantity != 1);
curItemCode = ExportUtil.BuildPlaceholderRegex(Placeholder_CurItem_Quantity).Replace(curItemCode, curItem.Quantity.ToString());
StyrItem item = _cachedDbAccess.GetItemById(curItem.ItemId).Result;
if (item != null)
{
ExportObjectData itemExportData = new ExportObjectData();
itemExportData.ExportData.Add(ExportConstants.ExportDataObject, item);
itemExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeItem);
curItemCode = _itemPlaceholderResolver.FillPlaceholders(curItemCode, itemExportData).Result;
}
inventoryCode += curItemCode;
++itemIndex;
}
return(inventoryCode);
}
/// <summary>
/// Builds a condition element from parsed data
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="project">Project</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <param name="exportSettings">Export Settings</param>
/// <returns>Condition string</returns>
public override string BuildConditionElementFromParsedData(InventoryConditionResolver.InventoryConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, KortistoNpc npc, ExportSettings exportSettings)
{
ExportTemplate conditionTemplate = _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, _isPlayer ? TemplateType.TaleConditionPlayerInventory : TemplateType.TaleConditionNpcInventory).Result;
StyrItem item = _cachedDbAccess.GetItemById(parsedData.ItemId).Result;
if (item == null)
{
errorCollection.AddDialogItemNotFoundError();
return(string.Empty);
}
ExportObjectData itemExportData = new ExportObjectData();
itemExportData.ExportData.Add(ExportConstants.ExportDataObject, item);
itemExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeItem);
string conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Operator).Replace(conditionTemplate.Code, GetOperatorFromTemplate(project, parsedData.Operator, errorCollection));
conditionCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Quantity).Replace(conditionCode, parsedData.Quantity.ToString());
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_Operator_IsAtLeast_Start, Placeholder_Operator_IsAtLeast_End, parsedData.Operator == CompareOperator_AtLeast);
conditionCode = ExportUtil.RenderPlaceholderIfTrue(conditionCode, Placeholder_Operator_IsAtMaximum_Start, Placeholder_Operator_IsAtMaximum_End, parsedData.Operator == CompareOperator_AtMaximum);
_itemPlaceholderResolver.SetErrorMessageCollection(errorCollection);
conditionCode = _itemPlaceholderResolver.FillPlaceholders(conditionCode, itemExportData).Result;
return(conditionCode);
}
/// <summary>
/// Returns the value object to use for scriban exporting
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="project">Project</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="flexFieldObject">Flex field object to which the dialog belongs</param>
/// <param name="exportSettings">Export Settings</param>
/// <returns>Value Object</returns>
protected override async Task <ScribanInventoryConditionData> GetExportObject(InventoryConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
KortistoNpc npc = await ConditionRenderingUtil.GetExportNpc(_cachedDbAccess, project, flexFieldObject, errorCollection, _isPlayer);
if (npc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(null);
}
StyrItem item = await _cachedDbAccess.GetItemById(parsedData.ItemId);
if (item == null)
{
errorCollection.AddDialogItemNotFoundError();
return(null);
}
ScribanInventoryConditionData conditionData = new ScribanInventoryConditionData();
ScribanExportNpc convertedNpc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection);
convertedNpc.IsPlayer = npc.IsPlayerNpc;
conditionData.Npc = convertedNpc;
conditionData.SelectedItem = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportItem>(null, null, item, exportSettings, errorCollection);
conditionData.OriginalOperator = parsedData.Operator == InventoryConditionData.CompareOperator_AtLeast ? "AtLeast" : "AtMaximum";
conditionData.Operator = await ConditionRenderingUtil.GetItemCompareOperatorFromTemplate(_defaultTemplateProvider, project, parsedData.Operator, errorCollection);
conditionData.Quantity = parsedData.Quantity;
return(conditionData);
}
/// <summary>
/// Loads the inventory
/// </summary>
/// <param name="parsedTemplate">Parsed scriban template</param>
/// <param name="inputNpc">Input npc</param>
/// <returns>List of items</returns>
private async Task<List<ScribanExportInventoryItem>> LoadInventory(Template parsedTemplate, KortistoNpc inputNpc)
{
if(inputNpc.Inventory == null || !inputNpc.Inventory.Any())
{
return new List<ScribanExportInventoryItem>();
}
GoNorthProject project = await _exportCachedDbAccess.GetUserProject();
ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id);
List<ScribanExportInventoryItem> inventoryItems = new List<ScribanExportInventoryItem>();
List<StyrItem> items = await _exportCachedDbAccess.GetItemsById(inputNpc.Inventory.Select(i => i.ItemId).ToList());
foreach(KortistoInventoryItem curItem in inputNpc.Inventory)
{
StyrItem loadedItem = items.FirstOrDefault(i => i.Id == curItem.ItemId);
if(loadedItem == null)
{
continue;
}
ScribanExportInventoryItem exportItem = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject<ScribanExportInventoryItem>(null, parsedTemplate, loadedItem, exportSettings, _errorCollection);
exportItem.Quantity = curItem.Quantity;
exportItem.IsEquipped = curItem.IsEquipped;
inventoryItems.Add(exportItem);
}
return inventoryItems;
}
/// <summary>
/// Compares an item
/// </summary>
/// <param name="itemId">Id of the item</param>
/// <param name="currentItem">Current item, if null the item will be loaded</param>
/// <returns>Compare Result</returns>
public async Task <CompareResult> CompareItem(string itemId, StyrItem currentItem = null)
{
if (currentItem == null)
{
currentItem = await _itemDbAccess.GetFlexFieldObjectById(itemId);
}
StyrItem oldItem = await _itemSnapshotDbAccess.GetSnapshotById(itemId);
return(CompareObjects(currentItem, oldItem));
}
/// <summary>
/// Returns the item use
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Value Object</returns>
private async Task <IFlexFieldExportable> GetItem(InventoryActionData parsedData, ExportPlaceholderErrorCollection errorCollection)
{
StyrItem item = await _cachedDbAccess.GetItemById(parsedData.ItemId);
if (item == null)
{
errorCollection.AddDialogItemNotFoundError();
return(null);
}
return(item);
}
/// <summary>
/// Returns the value object to use
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="flexFieldObject">Flex field object</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Value Object</returns>
protected override async Task <IFlexFieldExportable> GetValueObject(SpawnObjectActionData parsedData, FlexFieldObject flexFieldObject, ExportPlaceholderErrorCollection errorCollection)
{
StyrItem foundItem = await _cachedDbAccess.GetItemById(parsedData.ObjectId);
if (foundItem == null)
{
errorCollection.AddDialogItemNotFoundError();
return(null);
}
return(foundItem);
}
/// <summary>
/// Returns an item by its id
/// </summary>
/// <param name="itemId">Item id</param>
/// <returns>Item</returns>
public async Task <StyrItem> GetItemById(string itemId)
{
if (_cachedItems.ContainsKey(itemId))
{
return(_cachedItems[itemId]);
}
StyrItem item = await _itemDbAccess.GetFlexFieldObjectById(itemId);
_cachedItems.Add(itemId, item);
return(item);
}
/// <summary>
/// Syncs styr marker label
/// </summary>
/// <param name="map">Map To sync</param>
/// <returns>Task</returns>
private async Task SyncStyrMarkerLabels(KartaMap map)
{
if (map.ItemMarker == null)
{
return;
}
foreach (ItemMapMarker curMarker in map.ItemMarker)
{
StyrItem curItem = await _styrItemDbAccess.GetFlexFieldObjectById(curMarker.ItemId);
if (curItem == null)
{
continue;
}
curMarker.ItemName = curItem.Name;
}
}
/// <summary>
/// Checks an item for update
/// </summary>
/// <param name="exportSnippet">Export Snippet</param>
/// <param name="objectId">Object Id</param>
/// <param name="timelineEvent">Timeline Event</param>
/// <returns>Result of update</returns>
private async Task <FlexFieldObject> CheckItemForUpdate(ObjectExportSnippet exportSnippet, string objectId, TimelineEvent timelineEvent)
{
StyrItem item = await _itemDbAccess.GetFlexFieldObjectById(objectId);
if (item == null)
{
return(null);
}
await _timelineService.AddTimelineEntry(exportSnippet.ProjectId, timelineEvent, exportSnippet.SnippetName, item.Name, item.Id);
CompareResult result = await _implementationStatusComparer.CompareItem(item.Id, item);
if (result.CompareDifference != null && result.CompareDifference.Count > 0)
{
item.IsImplemented = false;
await _itemDbAccess.UpdateFlexFieldObject(item);
}
return(item);
}
public async Task <IActionResult> FlagItemAsImplemented(string itemId)
{
// Check Data
StyrItem item = await _itemDbAccess.GetFlexFieldObjectById(itemId);
if (item == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
// Flag item as implemented
item.IsImplemented = true;
await _itemSnapshotDbAccess.SaveSnapshot(item);
await _itemDbAccess.UpdateFlexFieldObject(item);
// Add Timeline entry
await _timelineService.AddTimelineEntry(TimelineEvent.ImplementedItem, item.Id, item.Name);
return(Ok());
}
/// <summary>
/// Exports an object
/// </summary>
/// <param name="exportFormat">Format to export (Script, JSON or LanguageFile)</param>
/// <param name="id">Id of the object to export</param>
/// <param name="templateType">Template type</param>
/// <returns>Export result</returns>
private async Task <ExportObjectResult> RunExportObject(string exportFormat, string id, TemplateType templateType)
{
// Check Access
if ((templateType == TemplateType.ObjectNpc && !User.IsInRole(RoleNames.Kortisto)) ||
(templateType == TemplateType.ObjectItem && !User.IsInRole(RoleNames.Styr)) ||
(templateType == TemplateType.ObjectSkill && !User.IsInRole(RoleNames.Evne)))
{
throw new UnauthorizedAccessException();
}
// Get Exporter
string exporterKey = exportFormat.ToLowerInvariant();
if (!_exporters.ContainsKey(exporterKey))
{
throw new InvalidOperationException("Unknown Export Format");
}
IObjectExporter exporter = _exporters[exporterKey];
// Get Objects
bool objectFound = false;
ExportObjectData objectData = new ExportObjectData();
if (templateType == TemplateType.ObjectNpc)
{
KortistoNpc npc = await _npcDbAccess.GetFlexFieldObjectById(id);
if (npc != null)
{
objectData.ExportData.Add(ExportConstants.ExportDataObject, npc);
objectData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc);
TaleDialog dialog = await _dialogDbAccess.GetDialogByRelatedObjectId(id);
objectData.ExportData.Add(ExportConstants.ExportDataDialog, dialog);
objectFound = true;
}
}
else if (templateType == TemplateType.ObjectItem)
{
StyrItem item = await _itemDbAccess.GetFlexFieldObjectById(id);
if (item != null)
{
objectData.ExportData.Add(ExportConstants.ExportDataObject, item);
objectData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeItem);
objectFound = true;
}
}
else if (templateType == TemplateType.ObjectSkill)
{
EvneSkill skill = await _skillDbAccess.GetFlexFieldObjectById(id);
if (skill != null)
{
objectData.ExportData.Add(ExportConstants.ExportDataObject, skill);
objectData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeSkill);
objectFound = true;
}
}
else
{
throw new InvalidOperationException("Template Type not supported for exporting");
}
if (!objectFound)
{
throw new KeyNotFoundException();
}
// Get Template
ExportTemplateByObjectIdResult template = await GetValidExportTemplateByIdAndType(id, templateType);
// Run Export
ExportObjectResult result = await exporter.ExportObject(template.Template, objectData);
result.ObjectFilename = ((FlexFieldObject)objectData.ExportData[ExportConstants.ExportDataObject]).Name;
string regexSearch = Regex.Escape(new string(Path.GetInvalidFileNameChars()));
Regex illegalCharRegex = new Regex(string.Format("[{0}]", regexSearch));
result.ObjectFilename = illegalCharRegex.Replace(result.ObjectFilename, string.Empty);
return(result);
}
/// <summary>
/// Copy Constructor from Base item
/// </summary>
/// <param name="baseItem">Base Item</param>
public ItemJsonExportObject(StyrItem baseItem)
{
ExportSnippets = new List <ObjectExportSnippet>();
JsonExportPropertyFill.FillBaseProperties(this, baseItem);
}
