public async Task <IActionResult> PutTag(long id, Tag tag)
{
if (id != tag.Id)
{
return(BadRequest());
}
_context.Entry(tag).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TagExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Create([Bind("Id,Name")] Tenant tenant)
{
if (ModelState.IsValid)
{
_context.Add(tenant);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tenant));
}
public async Task <IActionResult> Create(int tenantId, [Bind("Id,Value")] Tag tag)
{
if (ModelState.IsValid)
{
tag.TenantId = tenantId;
_context.Add(tag);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tag));
}
private async Task <IEnumerable <Tag> > GetTags(IEnumerable <String> tags, UserIndentity user)
{
if (tags == null)
{
return(null);
}
var tagsContext = _tagContext.Tags.ToArray();
var responceTags = new List <Tag>();
Tag tag = null;
foreach (var strTag in tags)
{
tag = await _tagContext.Tags.FirstOrDefaultAsync(t => t.Name == strTag);
if (tag == null)
{
tag = new Tag
{
UserCreatedId = user.Id,
Name = strTag
};
await _tagContext.Tags.AddAsync(tag);
}
responceTags.Add(tag);
tag = null;
}
await _tagContext.SaveChangesAsync();
return(responceTags.Count == 0 ? null : responceTags);
}
public async Task DeleteTag(CommandContext context, [Description("Tag name")] string key)
{
await context.TriggerTypingAsync();
using (var db = new TagContext())
{
var tag = db.Tags.FirstOrDefault(t => t.Key.ToLower() == key.ToLower());
if (tag == null)
{
var error = await context.RespondAsync($"`{key}` is not a valid tag. " +
$"Type `{Program.AppSettings.CommandPrefix}tag list` for a list of tags.");
await Task.Delay(5000)
.ContinueWith(t => error.DeleteAsync())
.ContinueWith(t => context.Message.DeleteAsync());
return;
}
db.Remove(tag);
await db.SaveChangesAsync();
}
await context.RespondAsync($"Deleted tag `{key}`");
}
public async Task EditTag(CommandContext context, [Description("Tag name")] string key, [Description("Tag value"), RemainingText] string value)
{
if (String.IsNullOrEmpty(value))
{
throw new ArgumentException();
}
await context.TriggerTypingAsync();
using (var db = new TagContext())
{
var tag = db.Tags.FirstOrDefault(t => t.Key.ToLower() == key.ToLower());
if (tag == null)
{
var error = await context.RespondAsync($"`{key}` is not a valid tag. " +
$"Type `{Program.AppSettings.CommandPrefix}tag list` for a list of tags.");
await Task.Delay(5000)
.ContinueWith(t => error.DeleteAsync())
.ContinueWith(t => context.Message.DeleteAsync());
return;
}
tag.Value = value;
db.Update(tag);
await db.SaveChangesAsync();
}
await context.RespondAsync($"Edited tag `{key}`");
}
public async Task NewTag(CommandContext context, [Description("Tag name")] string key, [Description("Tag value"), RemainingText] string value)
{
if (String.IsNullOrEmpty(value))
{
throw new ArgumentException();
}
await context.TriggerTypingAsync();
using (var db = new TagContext())
{
var tag = db.Tags.FirstOrDefault(t => t.Key.ToLower() == key.ToLower());
if (tag != null)
{
var error = await context.RespondAsync($"Tag `{key}` already exists");
await Task.Delay(5000)
.ContinueWith(t => error.DeleteAsync())
.ContinueWith(t => context.Message.DeleteAsync());
return;
}
tag = new Tag {
Key = key, Value = value
};
db.Add(tag);
await db.SaveChangesAsync();
}
await context.RespondAsync($"Created tag `{key}`");
}
public async Task <bool> TryAddTagAsync(TagValue entity)
{
if (_db == null)
{
_db = new TagContext();
}
await _db.Database.EnsureCreatedAsync();
if (await _db.Tags.AnyAsync(x => x.Tag == entity.Tag))
{
return(false);
}
await _db.Tags.AddAsync(entity);
await _db.SaveChangesAsync();
return(true);
}
public async Task <int> AddNewTag(TagModel model)
{
var newTag = new Tag()
{
TagName = model.TagName,
HasEndTag = model.HasEndTag,
CreatedAt = DateTime.UtcNow,
};
await _context.Tags.AddAsync(newTag);
await _context.SaveChangesAsync();
return(newTag.TagId);
}
public async Task <int> AddNewUI(GenUIModel model)
{
var newUI = new GenUI()
{
Width = model.Width,
Height = model.Height,
CreatedAt = DateTime.UtcNow,
Tags = model.Tags,
Regions = model.Regions,
};
await _context.GenUIs.AddAsync(newUI);
await _context.SaveChangesAsync();
return(newUI.GenUIId);
}
public async Task <int> AddNewRegion(RegionModel model)
{
var newRegion = new Region()
{
Width = model.Width,
Height = model.Height,
LeftPos = model.LeftPos,
RightPos = model.RightPos,
CreatedAt = DateTime.UtcNow,
TagId = model.TagId,
GenUI = model.GenUI,
};
await _context.Regions.AddAsync(newRegion);
await _context.SaveChangesAsync();
return(newRegion.RegionId);
}
public async Task <ActionResult> ItemCreate(string collectionId, string Title, string Description, string ShortDescription, string exitionalString, string Tags, bool goToNew, string ImageUrl)
{
Collection collection = _collectionContext.Collections
.Where(o => o.Id == collectionId)
.FirstOrDefault();
User user = await _userManager.FindByNameAsync(collection.UserName);
Dictionary <string, string[]> CollectionFields = JsonConvert.DeserializeObject <Dictionary <string, string[]> >(collection.Fields);
Dictionary <string, string> ItemFields = new Dictionary <string, string>();
//var markdown = new MarkdownSharp.Markdown();
foreach (var colStr in CollectionFields)
{
string type = colStr.Key;
foreach (var colName in colStr.Value)
{
string name = colName;
string value = Request.Form[name];
if (value == "" || value == null)
{
value = "off";
}
string s = type + "$$$$$" + markdown.Transform(value);
ItemFields.Add(markdown.Transform(name), s);
}
}
string html = markdown.Transform(Description);
string title = markdown.Transform(Title);
Item item = new Item
{
Id = Guid.NewGuid().ToString(),
CollectionId = collectionId,
UserName = collection.UserName,
Title = title,
Description = html,
Tags = Tags,
CollectionName = collection.Title,
ImageUrl = ImageUrl,
OptionalFields = JsonConvert.SerializeObject(ItemFields),
nComments = 0,
nLikes = 0,
Type = "Item",
Date = DateTime.Now
};
List <Tag> Tagss = _tagContext.Tags.ToList();
string[] ListTag = Tags.Split(" ");
foreach (var tag in ListTag)
{
var result = _tagContext.Tags.Where(o => o.Text == tag).SingleOrDefault();
if (result == null)
{
Tag Tag = new Tag()
{
Id = Guid.NewGuid().ToString(),
Text = tag
};
_tagContext.Add(Tag);
}
;
}
await _tagContext.SaveChangesAsync();
_itemContext.Add(item);
collection.nItems++;
user.nItems++;
await _userManager.UpdateAsync(user);
await _collectionContext.SaveChangesAsync();
await _itemContext.SaveChangesAsync();
if (goToNew == true)
{
return(RedirectToAction("Create", "Item", new { collectionId = collection.Id }));
}
return(RedirectToAction("Collection", "Collection", new { collectionId = collection.Id }));
}
public async Task SubmitTag(CommandContext context, [Description("Tag name")] string key, [Description("Tag value"), RemainingText] string value)
{
if (String.IsNullOrEmpty(value))
{
throw new ArgumentException();
}
await context.TriggerTypingAsync();
var moderation = context.Guild.Channels.FirstOrDefault(ch => ch.Name == "moderation");
if (moderation == null)
{
return;
}
using (var db = new TagContext())
{
var tag = db.Tags.FirstOrDefault(t => t.Key.ToLower() == key.ToLower());
if (tag != null)
{
var error = await context.RespondAsync($"Tag `{key}` already exists");
await Task.Delay(5000)
.ContinueWith(t => error.DeleteAsync())
.ContinueWith(t => context.Message.DeleteAsync());
return;
}
}
await context.RespondAsync($"{context.User.Mention} your tag `{key}` has been submitted for approval");
var embed = new DiscordEmbedBuilder {
Timestamp = context.Message.Timestamp
};
var author = context.User as DiscordMember;
embed.WithAuthor($"{author.Nickname ?? author.Username}", "", author.AvatarUrl);
embed.AddField("Key", $"`{key}`");
embed.AddField("Value", value);
var message = await moderation.SendMessageAsync("New tag submission:", false, embed.Build());
var approval = DiscordEmoji.FromUnicode("✅");
var denial = DiscordEmoji.FromUnicode("❌");
await message.CreateReactionAsync(approval);
await message.CreateReactionAsync(denial);
await Task.Delay(2000);
var response = await Program.Interactivity.WaitForMessageReactionAsync(
e => e == approval || e == denial,
message,
null,
TimeSpan.FromHours(8));
await message.DeleteAsync();
await moderation.TriggerTypingAsync();
if (response == null || response.Emoji == denial)
{
await moderation.SendMessageAsync($"Denied tag `{key}`");
await context.Member.SendMessageAsync($"{denial} Your tag has been denied", false, embed.Build());
}
else
{
await moderation.SendMessageAsync($"Created tag `{key}`");
using (var db = new TagContext())
{
db.Tags.Add(new Tag {
Key = key, Value = value
});
await db.SaveChangesAsync();
}
await context.Member.SendMessageAsync($"{approval} Your tag has been approved", false, embed.Build());
}
}