public void GameSteps()
{
resources += CreateResource.Updateh(this);
if (resources.People > peopleLimit)
{
resources.People = peopleLimit; //переделать
}
}
public async virtual Task <IActionResult> CreateAsync(ResourceModel <TResource> resourceModel)
{
if (!User.IsAuthorized(ResourceType))
{
return(Unauthorized());
}
var createResourceEvent = new CreateResource <TResource>(resourceModel);
var context = await _mediator.Send(createResourceEvent);
if (context != null)
{
resourceModel = context;
}
if (resourceModel.Errors.Any())
{
foreach (var error in resourceModel.Errors)
{
ModelState.AddModelError(error.Key, error.Value);
}
}
if (!ModelState.IsValid)
{
return(PartialView("_Editor", resourceModel));
}
int newResourceID = await _repository.CreateAsync(resourceModel.Resource, UserID);
if (newResourceID == 0)
{
return(NoContent());
}
_logger.LogResourceCreated(ResourceType, resourceModel.ID);
var resourceCreatedEvent = new ResourceCreated <TResource>(resourceModel.Resource);
await _mediator.Publish(resourceCreatedEvent);
var resourcePersistedEvent = new ResourcePersisted <TResource>();
await _mediator.Publish(resourcePersistedEvent);
var controllerName = ControllerContext.RouteData.Values["controller"].ToString();
return(Created(Url.Action("ReadAsync", controllerName, new { id = newResourceID }), newResourceID));
}
public override Activity GenerateActivityOnWorkflow(SequentialWorkflow workflow)
{
Logger.Instance.WriteMethodEntry();
try
{
// Create a new instance of the CreateResource activity and assign
// dependency property values based on inputs to standard activity controls
CreateResource wfa = new CreateResource
{
ActivityDisplayName = this.activityDisplayName.Value,
ResourceType = this.resourceType.Value,
Advanced = this.advanced.Value,
QueryResources = this.queryResources.Value,
ActivityExecutionCondition = this.activityExecutionCondition.Value,
Iteration = this.iteration.Value,
ActorType = GetActorType(this.actorType.Value),
ActorString = this.actorString.Value,
ApplyAuthorizationPolicy = this.applyAuthorizationPolicy.Value,
CreatedResourceIdTarget = this.createdResourceIdTarget.Value,
CheckForConflict = this.checkForConflict.Value,
ConflictFilter = this.conflictFilter.Value,
ConflictingResourceIdTarget = this.conflictingResourceIdTarget.Value,
FailOnConflict = this.failOnConflict.Value
};
// Convert the definition listings (web controls) to hash tables which can be serialized to the XOML workflow definition
// A hash table is used due to issues with deserialization of lists and other structured data
DefinitionsConverter queriesConverter = new DefinitionsConverter(this.queries.DefinitionListings);
DefinitionsConverter attributesConverter = new DefinitionsConverter(this.attributes.DefinitionListings);
wfa.QueriesTable = queriesConverter.DefinitionsTable;
wfa.AttributesTable = attributesConverter.DefinitionsTable;
return(wfa);
}
catch (Exception e)
{
Logger.Instance.ReportError(e);
throw;
}
finally
{
Logger.Instance.WriteMethodExit();
}
}
/// <summary>
/// This method initializes activity UI controls to their default values.
/// </summary>
/// <param name="activity">An instance of the current workflow activity. This provides a way to extract the values of the properties to display in the UI.</param>
public override void LoadActivitySettings(Activity activity)
{
Logger.Instance.WriteMethodEntry();
try
{
// Cast the supplied activity as a CreateResource activity
CreateResource wfa = activity as CreateResource;
if (wfa == null)
{
return;
}
// Set form control values based on the activity's dependency properties
this.activityDisplayName.Value = wfa.ActivityDisplayName;
this.resourceType.Value = wfa.ResourceType;
this.advanced.Value = wfa.Advanced;
this.queryResources.Value = wfa.QueryResources;
this.activityExecutionCondition.Value = wfa.ActivityExecutionCondition;
this.iteration.Value = wfa.Iteration;
this.actorType.Value = wfa.ActorType.ToString();
this.actorString.Value = wfa.ActorString;
this.applyAuthorizationPolicy.Value = wfa.ApplyAuthorizationPolicy;
this.createdResourceIdTarget.Value = wfa.CreatedResourceIdTarget;
this.checkForConflict.Value = wfa.CheckForConflict;
this.conflictFilter.Value = wfa.ConflictFilter;
this.conflictingResourceIdTarget.Value = wfa.ConflictingResourceIdTarget;
this.failOnConflict.Value = wfa.FailOnConflict;
this.queries.LoadActivitySettings(wfa.QueriesTable);
this.attributes.LoadActivitySettings(wfa.AttributesTable);
}
catch (Exception e)
{
Logger.Instance.ReportError(e);
throw;
}
finally
{
Logger.Instance.WriteMethodExit();
}
}
public HttpResponseMessage Post(CreateResource value)
{
var resource = new Resources();
resource.Category = value.Category;
resource.Description = value.Description;
resource.ResourceName = value.ResourceName;
resource.ResourceUrl = value.ResourceUrl;
resource.Date = value.Date;
resource.Tags = new List <Tags>();
foreach (var t in value.TagNames)
{
resource.Tags.Add(new Tags {
TagName = t
});
}
;
try
{
if (value == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Incorrect Model"));
}
else
{
db.Resources.Add(resource);
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
/// <summary>
/// Given a *sorted* list of source data items (currentItems),
/// and a *sorted* list of resources:
/// For each source item that doesn't have a matching resource, attempt to create a resource.
/// For each resource that doesn't have a matching source item, destroy that resource.
/// For each source item with a matching resource, update the resource.
/// </summary>
/// <remarks>
/// After this Sync, the list of resources will have exactly one resource for each item
/// in currentItems, and currentItems and resources will be the same length.
/// The exception is if the creator function returns false for any item(s), then those item(s)
/// will not have matching resources, and resources will be shorter than currentItems.
/// In any case, resources will remain sorted.
/// Sync completes in a single pass over the data, so in O(max(currentItems.Count, resources.Count)) time.
/// </remarks>
/// <typeparam name="ItemType">Type of source items.</typeparam>
/// <typeparam name="ResourceType">Type of resources.</typeparam>
/// <param name="currentItems">List of current source items.</param>
/// <param name="resources">List of resources to by synced to currentItems.</param>
/// <param name="compareIds">Function to compare an item with a resource. See above.</param>
/// <param name="creator">Callback to create a missing resource. See above.</param>
/// <param name="updater">Callback to update an existing resource. See above.</param>
/// <param name="destroyer">Callback to destroy a resource which no longer has a matching source item.</param>
public static void Sync <ItemType, ResourceType>(
IReadOnlyList <ItemType> currentItems,
List <ResourceType> resources,
CompareToResource <ItemType, ResourceType> compareIds,
CreateResource <ItemType, ResourceType> creator,
UpdateResource <ItemType, ResourceType> updater,
DestroyResource <ResourceType> destroyer)
{
int iRsrc = resources.Count - 1;
int iItem = currentItems.Count - 1;
while (iRsrc >= 0 && iItem >= 0)
{
/// If the existing resource is greater than the current item,
/// then there is no corresponding current item. So delete the resource.
int comparison = compareIds(currentItems[iItem], resources[iRsrc]);
if (comparison < 0)
{
/// items id less than resources, means
/// no item for this resource.
/// delete the surplus resource.
destroyer(resources[iRsrc]);
resources.RemoveAt(iRsrc);
--iRsrc;
/// Remain on iItem
}
/// If the existing resource is less, then we are missing a resource for the larger current item.
/// Add it now.
else if (comparison > 0)
{
/// items id greater than resources, means
/// for this item, no matching resource.
/// create and add.
ResourceType resource;
if (creator(currentItems[iItem], out resource))
{
resources.Insert(iRsrc + 1, resource);
}
/// If successful, now ci[iItem] <==> re[iRsrc+1]. So move on to ci[iItem-1] / re[iRsrc];
/// If failed, we've tried ci[iItem] (which failed) and re[] is unchanged.
/// So either way move on to ci[iItem-1] / re[iRsrc]
--iItem;
}
else
{
/// item and resource match, just update.
updater(currentItems[iItem], resources[iRsrc]);
--iItem;
--iRsrc;
}
}
// If iRsrc && iItem are both less than zero, then we are done.
// If iRsrc < 0 but iItem >= 0, then we need more resources created, from iItem on down.
// If iRsrc >= 0 but iItem < 0, then from iRsrc down needs to be deleted.
Debug.Assert(iRsrc < 0 || iItem < 0);
while (iItem >= 0)
{
ResourceType resource;
if (creator(currentItems[iItem], out resource))
{
resources.Insert(0, resource);
}
--iItem;
}
while (iRsrc >= 0)
{
destroyer(resources[iRsrc]);
resources.RemoveAt(iRsrc);
--iRsrc;
}
Debug.Assert(resources.Count <= currentItems.Count);
}
protected void Initialize(CreateResource res)
{
}
protected Foo(CreateResource res)
{
Initialize(res);
}
public JsonNetResult EditResource(CreateResource res, string editID)
{
try
{
var itemID = Guid.Parse(editID);
//Update ResoureItem
ResourceItem originalResource = new ResourceItem()
{
ItemID = itemID,
Title = res.Title,
ItemDescription = res.ItemDescription,
Url = res.Url,
UrlThumbnail = res.UrlThumbnail,
TypeID = res.TypeID,
StatusID = res.StatusID,
PostDate = res.PostDate ?? DateTime.Now.ToCST(),
Language = res.Language,
CreatedDate = DateTime.Now.ToCST(),
};
Exigo.ModifyResourceItem(originalResource);
//Current Availabilities
List <ResourceAvailability> currentAvailability = Exigo.GetResourceAvailabilities(new GetResourceAvailabilitiesRequest()
{
ItemID = originalResource.ItemID
}).ToList();
//Wanted Availabilities
List <ResourceAvailability> keepAvailabilities = new List <ResourceAvailability>();
List <Available> neededAvailabilities = new List <Available>();
foreach (var market in res.Markets)
{
var availability = new Available();
availability.Language = res.Language;
availability.Market = market;
var exist = currentAvailability.Where(ca => ca.Language == availability.Language && ca.Market == availability.Market).FirstOrDefault();
if (exist == null)
{
neededAvailabilities.Add(availability);
}
else
{
keepAvailabilities.Add(exist);
}
}
//Add NEW Availabilities
foreach (var avail in neededAvailabilities)
{
ResourceAvailability availableresource = new ResourceAvailability()
{
AvailabilityID = Guid.NewGuid(),
ItemID = originalResource.ItemID,
Market = avail.Market,
Language = avail.Language
};
Exigo.CreateResourceAvailabilities(availableresource);
}
//Delete Availabilities no longer wanted
List <Guid> deleteAvailabilities = currentAvailability.Except(keepAvailabilities).Select(t => t.AvailabilityID).ToList();
Exigo.DeleteResourceAvailabilities(deleteAvailabilities);
//Modify ResourceCategoryItems
// Current ResourceCategoryItems CategoryIDs
var RCI = Exigo.GetResourceCategoryItems(new GetResourceCategoryItemsRequest()
{
ItemID = originalResource.ItemID
});
var currentRCI = RCI.Select(rci => rci.CategoryID);
// Wanted CategoryIDs
var wantedRCI = res.CategoryID;
// Needed CategoryIDs
var neededRCI = wantedRCI.Except(currentRCI);
//Add New CategoryItems
foreach (var category in neededRCI)
{
var lastResource = Exigo.GetResourceCategoryItems(new GetResourceCategoryItemsRequest()
{
CategoryID = category
})
.OrderByDescending(r => r.ItemOrder)
.FirstOrDefault();
int lastItemOrder = InitialOrderValue - 1;
if (lastResource != null)
{
lastItemOrder = lastResource.ItemOrder;
}
ResourceCategoryItem categoryItem = new ResourceCategoryItem()
{
ItemID = originalResource.ItemID,
CategoryID = category,
ItemOrder = lastItemOrder
};
Exigo.CreateResourceCategoryItem(categoryItem);
}
//Delete Unwanted CategoryItems
var unwantedRCICategoryIDs = currentRCI.Except(wantedRCI).ToList();
if (unwantedRCICategoryIDs.Any())
{
Exigo.DeleteResourceCategoryItems(itemID, unwantedRCICategoryIDs);
}
List <Tag> tags = new List <Tag>();
if (res.Keywords.Any())
{
// check to see if tag existis with these keywords. if not add it
//Get A List Of Tags Using Provided Keywords
var existingTags = Exigo.GetTagsForResources(new GetTagsForResourcesRequest()
{
Names = res.Keywords
});
var existingTagNames = existingTags.Select(et => et.Name);
//Get a List of Keywords we need to make tags for
var newTagsneeded = res.Keywords.Except(existingTagNames);
//Create The New Tags
List <Tag> NewlyCreatedTags = new List <Tag>();
foreach (var keyword in newTagsneeded)
{
Tag newTag = new Tag()
{
TagID = Guid.NewGuid(),
Name = keyword
};
NewlyCreatedTags.Add(newTag);
Exigo.CreateTag(newTag);
}
//Combine existing and New Tags
var completeTagList = existingTags.Union(NewlyCreatedTags).ToList();
var completeTagIDs = completeTagList.Select(v => v.TagID);
//Get a list of ItemTags currently associated with the Item
var currentItemTagIDs = Exigo.GetResourceItemTags(new GetResourceItemTagsRequest()
{
ItemID = originalResource.ItemID
}).Select(v => v.TagID);
//Get a list of Tags we need to make ItemTags for
var newItemTagsneeded = completeTagList.Where(t => !currentItemTagIDs.Contains(t.TagID));
// Update ResourceItemTags Table with new Tags
foreach (var tagneeded in newItemTagsneeded)
{
ResourceItemTag rit = new ResourceItemTag()
{
TagID = tagneeded.TagID,
ItemID = itemID,
};
Exigo.CreateResourceItemTag(rit);
}
// remove any pivot table tags that are no longer being used for this resource
var nolongerwanted = currentItemTagIDs.Except(completeTagIDs).ToList();
if (nolongerwanted.Count > 0)
{
Exigo.DeleteResourceItemTags(nolongerwanted);
}
}
return(new JsonNetResult(new
{
success = true,
}));
}
catch (Exception ex)
{
return(new JsonNetResult(new
{
success = false,
message = ex.Message
}));
}
}
public JsonNetResult CreateResource(CreateResource res)
{
try
{
// Create Resource Item
ResourceItem resource = new ResourceItem()
{
ItemID = Guid.NewGuid(),
Title = res.Title,
ItemDescription = res.ItemDescription,
TypeID = res.TypeID,
Url = res.Url,
UrlThumbnail = res.UrlThumbnail,
CreatedDate = DateTime.Now.ToCST(),
PostDate = res.PostDate >= DateTime.Now.AddHours(1) ? res.PostDate : null,
StatusID = res.StatusID,
Language = res.Language
};
Exigo.CreateResourceItem(resource);
//Create Resource Category Item
foreach (var categoryID in res.CategoryID)
{
//2015-09-08
//Ivan S.
//66
//Sets the initial order for the new resource to the maximum number for that category
var lastResource = Exigo.GetResourceCategoryItems(new GetResourceCategoryItemsRequest()
{
CategoryID = categoryID
})
.OrderByDescending(r => r.ItemOrder)
.FirstOrDefault();
int lastCategoryOrder = InitialOrderValue - 1;
if (lastResource != null)
{
lastCategoryOrder = lastResource.ItemOrder;
}
var NewOrder = ++lastCategoryOrder;
ResourceCategoryItem categoryItem = new ResourceCategoryItem()
{
ItemID = resource.ItemID,
CategoryID = categoryID,
ItemOrder = NewOrder
};
Exigo.CreateResourceCategoryItem(categoryItem);
}
// Create the ResourceAvailability Entries
if (res.Markets != null && res.Markets.Count() > 0)
{
foreach (var CountryCode in res.Markets)
{
ResourceAvailability availableresource = new ResourceAvailability()
{
AvailabilityID = Guid.NewGuid(),
ItemID = resource.ItemID,
Market = CountryCode,
Language = res.Language
};
Exigo.CreateResourceAvailabilities(availableresource);
}
}
//Create Tags
List <Tag> Tags = new List <Tag>();
if (res.Keywords.Count() > 0)
{
var existingtags = Exigo.GetTagsForResources(new GetTagsForResourcesRequest()
{
Names = res.Keywords
});
var existingtagnames = existingtags.Select(t => t.Name).ToList();
var needtocreatetags = res.Keywords.Except(existingtagnames);
foreach (var name in needtocreatetags)
{
//See if Tag exist in DB if not create one
Tag newTag = new Tag()
{
TagID = Guid.NewGuid(),
Name = name
};
Exigo.CreateTag(newTag);
Tags.Add(newTag);
}
Tags.AddRange(existingtags);
}
// Create the ResourceItemTag Entries
if (Tags.Any())
{
foreach (var tag in Tags)
{
ResourceItemTag rTag = new ResourceItemTag()
{
TagID = tag.TagID,
ItemID = resource.ItemID
};
Exigo.CreateResourceItemTag(rTag);
}
}
return(new JsonNetResult(new
{
success = true,
}));
}
catch (Exception ex)
{
return(new JsonNetResult(new
{
success = false,
message = ex.Message
}));
}
}
private void OnCreateResource()
{
CreateResource?.Invoke(this, EventArgs.Empty);
}
