public int Create(int ownerId, DraftOptions options)
{
int draftId = _idService.CreateID();
var draft = new Draft(draftId, ownerId, options);
lock (_drafts)
_drafts[draftId] = draft;
return draftId;
}
public DraftRegisterDataModel(Draft draft)
{
Id = draft.Id;
UserId = draft.Author.Id;
Type = draft.Type;
Title = draft.Title;
Body = draft.Body;
LastModifiedDateTime = draft.LastModifiedDateTime;
Comment = draft.Comment;
}
public void InsertOrUpdate(Draft draft)
{
if (draft.id == default(long)) {
// New entity
db.Draft.AddObject(draft);
} else {
// Existing entity
db.Draft.Attach(draft);
db.ObjectStateManager.ChangeObjectState(draft, EntityState.Modified);
}
}
public static Contact FromDraftContact(Draft.Contact contact)
{
if (contact == null)
{
return new Contact();
}
return new Contact
{
Email = contact.Email,
Telephone = contact.Telephone,
Name = contact.ContactName
};
}
public async Task <Result> Handle(DraftPreviewQuery request, CancellationToken cancellationToken)
{
var draft = new Draft();
var updateInfo = _mapper.Map <DraftUpdateCommand>(request);
updateInfo.Summary = "Not Important";
var updateResult = draft.Update(updateInfo);
if (updateResult.Failed)
{
return(Result.MakeFailure(updateResult));
}
var publishResult = await draft.Publish(_dateProvider, _htmlProcessor);
if (publishResult.Failed)
{
return(Result.MakeFailure(publishResult));
}
return(Result.MakeSuccess(_mapper.Map <PostViewModel>(draft.Post)));
}
public void ValidateTestOnlyError()
{
var form = creator.form;
var context = creator.context;
var draft = new Draft {
FormId = form.Id,
};
draft.DataJson = JsonConvert.SerializeObject(new { AAA = "BBB", });
var errors = form.Validate(context, draft, ValidationLevel.Error);
Assert.AreEqual(errors.Count, 0);
draft.DataJson = JsonConvert.SerializeObject(new { AAA = "", });
errors = form.Validate(context, draft, ValidationLevel.Error);
Assert.AreEqual(errors.Count, 0);
draft.DataJson = JsonConvert.SerializeObject(new { });
errors = form.Validate(context, draft, ValidationLevel.Error);
Assert.AreEqual(errors.Count, 0);
}
public async Task Dont_publish_if_code_block_language_is_invalid()
{
var draft = new Draft();
var command = new DraftUpdateCommand
{
Title = "JS",
Summary = "Learn JS",
Tags = "js",
Language = Language.English,
Content = "<pre class=\"code\">\nclojure\nsome code</code>"
};
draft.Update(command);
var result = await draft.Publish(_dateProvider, _htmlProcesssor);
result.Failed.Should().BeTrue();
result.Errors
.First()
.Should()
.StartWith("Specified language in code block #1 is not valid");
}
public static Draft AddToDraftBody(Draft draft, string subject = null, string text = null, List <IUserInfo> to = null,
List <IUserInfo> cc = null, List <IUserInfo> bcc = null, List <IUserInfo> from = null,
List <FileStream> fileStream = null, CancellationToken cancellationToken = default(CancellationToken))
{
draft.NullInspect(nameof(draft));
if (draft.Message?.Raw == null)
{
throw new InvalidOperationException($"The {nameof(Draft.Message)} must contain a non-null Raw property.");
}
var decodedRaw = Base64.DecodeUrlSafeToBytes(draft.Message.Raw);
using (var stream = new MemoryStream(decodedRaw))
{
var mimeMessage = MimeMessage.Load(stream, cancellationToken);
FillMimeMessage(mimeMessage, subject, text, to, cc, bcc, from, fileStream);
var message = TransformMimeMessageToMessage(mimeMessage);
return(new Draft {
Message = message
});
}
}
private void CreateDraftSelectionsAndRosters(Draft draft)
{
var league = _leagueRepository.GetLeague(draft.LeagueId);
var totalTeams = league.Teams.Count();
var totalPlayers = _playerRepository.GetPlayerCount();
var totalRounds = Convert.ToInt32(Math.Floor(totalPlayers / Convert.ToDouble(totalTeams)));
for (int x = 0; x < totalRounds; x++)
{
foreach (var team in league.Teams)
{
if (x == 0)
{
//Create draft rosters on first round loop. Creates roster for each team
var draftTeamRosterCreateModel = new DraftTeamRosterCreateModel();
draftTeamRosterCreateModel.DraftId = draft.Id;
draftTeamRosterCreateModel.TeamId = team.Id;
var draftTeamRosterEntity = _mapper.Map <DraftTeamRoster>(draftTeamRosterCreateModel);
_draftTeamRosterRepository.AddTeamRosterToDraft(draft.Id, draftTeamRosterEntity);
if (!_mlbDraftRepository.Save())
{
throw new Exception("Creating a draft roster failed on save.");
}
}
var draftSelectionCreateModel = new DraftSelectionCreateModel();
draftSelectionCreateModel.DraftId = draft.Id;
draftSelectionCreateModel.TeamId = team.Id;
draftSelectionCreateModel.Round = x + 1;
var draftSelectionEntity = _mapper.Map <DraftSelection>(draftSelectionCreateModel);
_draftSelectionRepository.AddDraftSelectionToDraft(draft.LeagueId, draft.Id, draftSelectionEntity);
if (!_mlbDraftRepository.Save())
{
throw new Exception("Creating a draft selection failed on save.");
}
}
}
}
/// <summary>
/// Creates a test draft for running further tests.
/// </summary>
/// <param name="user">The AdWords user.</param>
/// <param name="baseCampaignId">The base campaign ID for the draft.</param>
/// <returns>The draft.</returns>
/// <remarks>We are returning the Draft itself, since there's no way to get
/// the draft campaign ID given a draft ID.</remarks>
public Draft AddDraft(AdWordsUser user, long baseCampaignId)
{
// Get the DraftService.
DraftService draftService =
(DraftService)user.GetService(AdWordsService.v201806.DraftService);
Draft draft = new Draft()
{
baseCampaignId = baseCampaignId,
draftName = "Test Draft #" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffffff")
};
DraftOperation draftOperation = new DraftOperation()
{
@operator = Operator.ADD,
operand = draft
};
return(draftService.mutate(new DraftOperation[]
{
draftOperation
}).value[0]);
}
public async Task Update_existing_drafts()
{
using (var db = _context.GetDb())
{
var draft = new Draft(0, "JS", null, Language.English, "Learn JS", "js, es", "<p>text</p>");
db.Drafts.Add(draft);
db.SaveChanges();
}
var result = await _handler.Handle(new DraftSaveCommand
{
Id = 1,
Title = "Functional JS",
Summary = "Learn FP with JS",
Tags = "js, es",
Language = Language.English,
Content = "<p>fp text</p>",
}, default);
result.Should().BeEquivalentTo(new
{
Published = false,
PostUrl = (string)null
});
using (var db = _context.GetDb())
{
db.Drafts.Single().Should().BeEquivalentTo(new
{
Id = 1,
Title = "Functional JS",
Summary = "Learn FP with JS",
Tags = "js, es",
Language = Language.English,
Content = "<p>fp text</p>"
});
}
}
public async Task 正常系_記事_作成と削除()
{
var draft1 = Draft.NewDraft(LogonUser, ItemType.Article);
draft1.Title = "title 正常系_記事_作成と削除 削除対象";
draft1.Body = "body 正常系_記事_作成と削除 削除対象";
draft1.ItemTags.Add(new ItemTag("tag1", "1.0.0"));
draft1.ItemTags.Add(new ItemTag("tag2", null));
var draft2 = Draft.NewDraft(LogonUser, ItemType.Article);
draft2.Title = "title 正常系_記事_作成と削除 削除しない";
draft2.Body = "title 正常系_記事_作成と削除 削除しない";
draft2.ItemTags.Add(new ItemTag("tag3", "1.0.0"));
draft2.ItemTags.Add(new ItemTag("tag4", null));
await DraftDbCommand.SaveAsync(draft1);
await DraftDbCommand.SaveAsync(draft2);
var created1 = await DraftDbCommand.FindAsync(draft1.Id, LogonUser);
created1.IsStructuralEqual(draft1);
var created2 = await DraftDbCommand.FindAsync(draft2.Id, LogonUser);
created2.IsStructuralEqual(draft2);
await DraftDbCommand.DeleteAsync(created1.Id, LogonUser);
var deleted = await DraftDbCommand.FindAsync(draft1.Id, LogonUser);
deleted.IsNull();
var undeleted = await DraftDbCommand.FindAsync(draft2.Id, LogonUser);
undeleted.IsNotNull();
undeleted.IsStructuralEqual(draft2);
}
public async Task 正常系_作成とIDでの抽出_非公開質問()
{
var draft = Draft.NewDraft(LogonUser, ItemType.Ask);
draft.Title = "title 正常系_作成とIDでの抽出_非公開質問";
draft.Body = "body 正常系_作成とIDでの抽出_非公開質問";
draft.Tags.Add(new Tag("tag1", "1.0.0"));
draft.Tags.Add(new Tag("tag2", null));
var item = draft.ToItem(false);
await ItemDbCommand.SaveAsync(item);
var created = await ItemDbCommand.FindAsync(item.Id);
created.IsStructuralEqual(item);
created.IsStructuralEqual(item);
Assert.AreEqual(draft.Id, created.Id);
Assert.AreEqual(draft.Title, created.Title);
Assert.AreEqual(draft.Body, created.Body);
created.Author.IsStructuralEqual(draft.Author);
}
public async Task <ActionResult> Save(DraftEditModel model)
{
model.EntryMode = EntryMode.SaveDraft;
TryValidateModel(model);
if (!ModelState.IsValid)
{
using (var parser = new MarkdownParser())
{
model.Html = parser.Transform(model.Body);
return(View("Edit", model));
}
}
var draft = await _draftDbCommand.FindAsync(model.Id) ?? Draft.NewDraft(LogonUser, model.ItemType);
Mapper.Map(model, draft);
draft.LastModifiedDateTime = DateTime.Now;
await _draftDbCommand.SaveAsync(draft);
return(RedirectToAction("Index", "Draft"));
}
public void ValidateTest()
{
var form = creator.form;
var context = creator.context;
var draft = new Draft {
FormId = form.Id,
};
draft.DataJson = JsonConvert.SerializeObject(new { AAA = "BBB", DDD__FORMCORE__EEE = "aa" });
var errors = form.Validate(context, draft);
//Console.WriteLine(errors);
Assert.AreEqual(0, errors.Count);
draft.DataJson = JsonConvert.SerializeObject(new { AAA = "", DDD__FORMCORE__EEE = "" });
errors = form.Validate(context, draft);
Assert.AreEqual(errors.Count, 2);
draft.DataJson = JsonConvert.SerializeObject(new { });
errors = form.Validate(context, draft);
Assert.AreEqual(errors.Count, 2);
}
public IActionResult Draft(int id)
{
DraftViewModel draftViewModel = new DraftViewModel();
var userId = _userManager.GetUserId(User);
Draft draft = _draftService.GetDraft(id);
Team userTeam = _teamService.GetUserTeam(draft);
Team availablePlayers = _teamService.GetAvailablePlayers(draft);
draftViewModel.LeagueName = draft.LeagueName;
draftViewModel.TeamName = userTeam.TeamName;
draftViewModel.DraftPosition = draft.UserDraftPosition;
draftViewModel.NumberOfTeams = draft.NumberOfTeams;
draftViewModel.MyPlayers = userTeam.Players.ToHashSet();
draftViewModel.AvailablePlayers = availablePlayers.Players.ToHashSet();
int pick = _draftService.GetPick(draft);
draftViewModel.pick = pick;
draftViewModel.round = _draftService.GetRound(pick, draft.NumberOfTeams);
return(View(draftViewModel));
}
public async Task 正常系_共同編集者が記事を更新()
{
var draft = Draft.NewDraft(_author, ItemType.Article);
draft.Title = "共同編集テスト_共同編集者が記事を更新";
draft.Body = "共同編集テスト_共同編集者が記事を更新";
var item = draft.ToItem(true);
await ItemDbCommand.SaveAsync(item);
var collaborator1 = new Collaborator(_collaborator1)
{
Role = RoleType.Owner
};
var collaborator2 = new Collaborator(_collaborator2)
{
Role = RoleType.Member
};
var collaborators = new[] { collaborator1, collaborator2 };
await ItemDbCommand.SaveCollaboratorsAsync(item, collaborators);
var newDraft = item.ToDraft(_collaborator1);
newDraft.Title = "共同編集テスト_共同編集者が記事を更新した";
newDraft.Body = "共同編集テスト_共同編集者が記事を更新した";
var newItem = newDraft.ToItem(true);
await ItemDbCommand.SaveAsync(newItem);
newItem.Author.Is(_author);
newItem.Editor.Is(_collaborator1);
var savedItem = await ItemDbCommand.FindAsync(newItem.Id);
savedItem.IsStructuralEqual(newItem);
}
public async Task <ActionResult <SaveDraftResponse> > SaveDraft(SaveDraftRequest request)
{
using (var dbContext = _implementationsContainer.GetLobToolsRepository() as LobToolsDbContext)
{
var draft = new Draft
{
ActionTypeId = request.ActionTypeId,
CreationTime = DateTime.Now,
EntityTypeId = request.EntityTypeId,
Identifier = request.Identifier ?? Guid.NewGuid(),
IsLastVersion = true,
JsonData = request.JsonData,
// TODO: The new OwnerUserId can be different from the old one. Is this a problem?
OwnerUserId = _usersService.GetUserId(User)
};
if (request.Identifier.HasValue)
{
var lastDraft = await dbContext.Drafts.Where(x => x.Identifier == request.Identifier)
.OrderByDescending(x => x.Version).FirstOrDefaultAsync();
draft.Version = lastDraft.Version + 1;
lastDraft.IsLastVersion = false;
}
else
{
draft.Version = 1;
}
dbContext.Drafts.Add(draft);
await dbContext.SaveChangesAsync();
return(new SaveDraftResponse
{
Identifier = draft.Identifier,
Version = draft.Version
});
}
}
private async Task Get()
{
Draft draft;
List <string> File = new List <string>(await FileIO.ReadLinesAsync(storageFile));
if (File.Count > 0)
{
foreach (var item in File)
{
string[] a = item.Split("---");
if (a[0] == "A")
{
draft = new Draft
{
dateTime = Convert.ToDateTime(a[1]),
Title = a[2],
Content = a[3],
};
drafts.Add(draft);
}
else if (a[0] == "Q")
{
AnswerDraft answerDraft = new AnswerDraft
{
dateTime = Convert.ToDateTime(a[1]),
QName = a[1],
Qid = Convert.ToInt32(a[2]),
Content = a[3],
};
answerDrafts.Add(answerDraft);
}
}
Draftlist.ItemsSource = drafts;
AnswerList.ItemsSource = answerDrafts;
}
}
public Draft CreateDraft(string draftName, int ownerId, int numberOfPicksPerPlayer, bool isPublic)
{
var draft = new Draft
{
Name = draftName,
CreatedDate = DateTime.Now,
MaximumPicksPerMember = numberOfPicksPerPlayer,
Public = isPublic,
Started = false,
Finished = false,
};
IDraftRepository dr = new DraftRepository();
IDraftMemberPositionsRepository dmpr = new DraftMemberPositionsRepository();
IMemberRepository mr = new MemberRepository();
draft.Owner = mr.GetById(ownerId);
draft.DraftSize = 0;
dr.Add(draft);
return(draft);
}
public async Task 正常系_共同編集者の変更()
{
var draft = Draft.NewDraft(_author, ItemType.Article);
draft.Title = "共同編集テスト_共同編集者の変更";
draft.Body = "共同編集テスト_共同編集者の変更";
var item = draft.ToItem(true);
await ItemDbCommand.SaveAsync(item);
var collaborator1 = new Collaborator(_collaborator1)
{
Role = RoleType.Owner
};
var collaborator2 = new Collaborator(_collaborator2)
{
Role = RoleType.Member
};
var collaborators = new[] { collaborator1, collaborator2 };
await ItemDbCommand.SaveCollaboratorsAsync(item, collaborators);
var collaborator3 = new Collaborator(_collaborator3)
{
Role = RoleType.Member
};
var newCollaborators = new[] { collaborator2, collaborator3 };
await ItemDbCommand.SaveCollaboratorsAsync(item, newCollaborators);
var savedItem = await ItemDbCommand.FindAsync(item.Id);
item.IsStructuralEqual(savedItem);
savedItem.Collaborators.ToArray().IsStructuralEqual(newCollaborators);
}
public async Task <IActionResult> Post([FromBody] DraftRequestDto request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
return(await Execute(async() =>
{
var content = await _broswer.GetContent(request.Url);
var draft = new Draft
{
Uri = new Uri(request.Url),
Picture = new Uri(request.Picture),
Title = request.Title,
Paragraphs = request.Paragraphs,
Tags = request.Tags,
User = new User
{
Id = _identityHelper.Id,
Username = _identityHelper.Username
}
};
await _draftService.Save(draft, content);
return _mapper.Map <DraftResponseDto>(draft);
}));
}
catch (ArgumentNullException)
{
return(BadRequest());
}
}
public void DeleteDraft(Draft draft)
{
_context.Drafts.Remove(draft);
}
/// <summary>
/// Creates a new <see cref="SchemaDraftAttribute"/>.
/// </summary>
/// <param name="draft">The supported draft.</param>
public SchemaDraftAttribute(Draft draft)
{
Draft = draft;
}
/// <summary>
/// 添加草稿
/// </summary>
/// <param name="d"></param>
/// <returns></returns>
public static int InsertDraft(Draft d)
{
return(DraftService.InsertDraft(d));
}
public void ProxyMessage(dynamic message)
{
try
{
if (!HttpContext.Current.Request.IsLocal)
{
return;
}
var broadcasterName = (string)message.BroadcasterName;
int mtgoDraftId = 0;
try
{
mtgoDraftId = (int)message.DraftId;
}
catch (RuntimeBinderException)
{
}
int mtgoTournamentId = 0;
try
{
mtgoTournamentId = (int)message.TournamentId;
}
catch (RuntimeBinderException)
{
}
Draft draft = null;
if (string.IsNullOrEmpty(broadcasterName))
{
throw new Exception("Broadcaster Name Required");
}
var broadcaster = _db.Broadcasters.SingleOrDefault(b => b.MtgoUsername == broadcasterName);
if (broadcaster == null)
{
throw new Exception("Invalid Broadcaster.");
}
dynamic clients = null;
if (message.Action != "start_draft")
{
if (mtgoDraftId > 0)
{
draft = _db.Drafts.SingleOrDefault(d => d.DraftId == mtgoDraftId && d.BroadcasterId == broadcaster.Id);
}
else if (mtgoTournamentId > 0)
{
draft = _db.Drafts.SingleOrDefault(d => d.TournamentId == mtgoTournamentId && d.BroadcasterId == broadcaster.Id);
}
if (draft == null)
{
throw new Exception(String.Format("Unable to find draft with draft_id='{0}'", mtgoDraftId));
}
clients = Clients.Group(String.Format("draft/{0}",
draft.Id
));
}
log.DebugFormat("Message from mtgo client broadcaster='{0}', mtgoDraftId='{1}', mtgoTournamentId='{2}', action='{3}'", broadcaster.Name, mtgoDraftId, mtgoTournamentId, message.Action);
switch ((string)message.Action)
{
case "start_draft":
var players = ((Newtonsoft.Json.Linq.JArray)message.Players).ToObject <int[]>();
draft = new Draft
{
DraftId = mtgoDraftId,
TournamentId = mtgoTournamentId,
Players = string.Join(",", players),
DraftStatus = DraftStatus.Drafting,
BroadcasterId = broadcaster.Id
};
_db.Drafts.Add(draft);
_db.SaveChanges();
{
Pipe.SendMessage("{0}|StartDraft|{1}",
broadcaster.Name,
draft.Id);
}
//Clients.Caller.startDraft(draft.Id);
break;
case "open_pack":
draft.CurrentPack++;
_db.Entry(draft).State = EntityState.Modified;
_db.SaveChanges();
break;
case "pending_selection":
{
var dir = (Direction)message.Direction;
var time = (int)message.Time;
var picks = ((Newtonsoft.Json.Linq.JArray)message.Picks).ToObject <int[]>();
var currentPick = 16 - picks.Length;
int playerCount = draft.Players.Split(',').Length;
int i = playerCount;
List <object> previousPicks = new List <object>();
while (currentPick - i > 0)
{
var previousPick =
_db.DraftPicks.SingleOrDefault(
dp =>
dp.DraftId == draft.Id && dp.Pack == draft.CurrentPack &&
dp.Pick == currentPick - i);
if (previousPick != null)
{
var previousPickCards = previousPick.Picks.Split(',').Select(p => Convert.ToInt32(p));
previousPicks.Add(new
{
PickId = previousPick.PickId,
Cards = _db.Cards.Include("CardSet").Where(c => previousPickCards.Contains(c.Id)).ToArray()
});
}
i += playerCount;
}
var draftPick = new DraftPick
{
DraftId = draft.Id,
PickId = null,
Picks = string.Join(",", picks),
Direction = dir,
Pick = currentPick,
Pack = draft.CurrentPack,
Time = time
};
_db.DraftPicks.Add(draftPick);
log.DebugFormat("Writing draft pick: {0}", draftPick);
var cards = _db.Cards.Include("CardSet").Where(c => picks.Contains(c.Id)).ToArray();
_db.SaveChanges();
log.DebugFormat("Calling pendingSelection: {0}, {1}, {2}, {3}, {4}, {5}", draftPick.Id, previousPicks, cards, draft.CurrentPack, dir, time);
clients.pendingSelection(
draftPick.Id, previousPicks, cards, draft.CurrentPack, dir, time);
}
break;
case "draft_selection":
{
var draftPick = _db.DraftPicks.OrderByDescending(d => d.Id)
.SingleOrDefault(d => d.DraftId == draft.Id && d.PickId == null);
var pick = (int)message.Pick;
if (draftPick != null)
{
draftPick.PickId = pick;
_db.Entry(draftPick).State = EntityState.Modified;
_db.SaveChanges();
}
clients.draftSelection(_db.Cards.Include("CardSet").Single(p => p.Id == pick), draft.CurrentPack);
}
break;
case "draft_ended":
{
draft.DraftStatus = DraftStatus.Completed;
_db.Entry(draft).State = EntityState.Modified;
_db.SaveChanges();
Pipe.SendMessage("{0}|EndDraft|{1}",
broadcaster.Name,
draft.Id);
}
break;
case "submit_deck":
{
var cards = ((Newtonsoft.Json.Linq.JArray)message.Cards).ToObject <string[]>();
draft.FinalDeck = string.Join(",", cards);
_db.Entry(draft).State = EntityState.Modified;
_db.SaveChanges();
}
break;
}
}
catch (Exception ex)
{
log.Error("Error on ProxyMessage: ", ex);
}
}
public async Task SaveAsync(Draft draft, CancellationToken cancellationToken)
{
if (draft == null) throw new ArgumentNullException("draft");
const string sqlDraft = @"
DELETE FROM [dbo].[DraftTags]
WHERE
[DraftId] = @Id
AND [UserId] = @UserId
;
IF EXISTS (SELECT * FROM [dbo].[Drafts] WHERE [Id] = @Id AND [UserId] = @UserId)
BEGIN
UPDATE [dbo].[Drafts]
SET [Type] = @Type,
[Title] = @Title,
[Body] = @Body,
[Comment] = @Comment,
[LastModifiedDateTime] = @LastModifiedDateTime
WHERE
[Id] = @Id
AND [UserId] = @UserId
END
ELSE
BEGIN
INSERT INTO [dbo].[Drafts] (
[Id],
[UserId],
[Type],
[Title],
[Body],
[Comment],
[LastModifiedDateTime]
) VALUES (
@Id,
@UserId,
@Type,
@Title,
@Body,
@Comment,
@LastModifiedDateTime
)
END
";
const string sqlTags = @"
INSERT INTO [dbo].[DraftTags] (
[DraftId],
[UserId],
[Name],
[Version],
[OrderNo]
) VALUES (
@DraftId,
@UserId,
@Name,
@Version,
@OrderNo
)
";
using (var cn = CreateConnection())
{
await cn.OpenAsync(cancellationToken).ConfigureAwait(false);
using (var tr = cn.BeginTransaction())
{
try
{
await cn.ExecuteAsync(sqlDraft, new DraftRegisterDataModel(draft), tr).ConfigureAwait(false);
var orderNo = 1;
foreach (var tag in draft.ItemTags)
{
await cn.ExecuteAsync(sqlTags, new {DraftId = draft.Id, UserId = draft.Editor.Id, tag.Name, tag.Version, OrderNo = orderNo}, tr).ConfigureAwait(false);
orderNo++;
}
tr.Commit();
}
catch
{
tr.Rollback();
throw;
}
}
}
}
// To Be Updated...
public Draft CreateDraft(DraftSettings settings)
{
Draft = new Draft(_model.Teams, settings);
return Draft;
}
public DraftDto(Draft draft, string ownerNick)
{
Owner = ownerNick;
Title = draft.Options.Title;
BoosterAcronyms = draft.Options.Packs.Select(p => p.Acronym).ToList();
}
public Draft CreateDraft()
{
var draft = new Draft();
_drafts.Add(draft);
return draft;
}
public async Task <ReturnViewModel> GetReturnViewModelAsync(long organisationId, int snapshotYear, long userId)
{
// get the user organisation
UserOrganisation userOrganisationFromDatabase = DataRepository.GetAll <UserOrganisation>()
.FirstOrDefault(uo => uo.UserId == userId && uo.OrganisationId == organisationId);
// throws an error when no user organisation was found
if (userOrganisationFromDatabase == null)
{
throw new AuthenticationException(
$"GetViewModelForSubmission: Failed to find the UserOrganisation for userId {userId} and organisationId {organisationId}");
}
var result = new ReturnViewModel();
// get the most recent submission for the given reporting year
Return returnFromDatabase = GetReturnFromDatabase(organisationId, snapshotYear);
// should provide late reason
result.ShouldProvideLateReason = IsHistoricSnapshotYear(userOrganisationFromDatabase.Organisation.SectorType, snapshotYear);
if (returnFromDatabase == null)
{
result.ReportInfo = await GetReportInfoModelWithDraftAsync(
userOrganisationFromDatabase.Organisation,
null,
snapshotYear,
userId);
if (result.ReportInfo?.Draft?.ReturnViewModelContent != null)
{
Draft tempDraft = result.ReportInfo.Draft;
result = result.ReportInfo.Draft.ReturnViewModelContent;
result.ReportInfo.Draft = tempDraft;
}
//Always create a new return if no previous return or latest last year
result.AccountingDate = GetSnapshotDate(userOrganisationFromDatabase.Organisation.SectorType, snapshotYear);
result.OrganisationId = organisationId;
result.EncryptedOrganisationId = userOrganisationFromDatabase.Organisation.GetEncryptedId();
result.SectorType = userOrganisationFromDatabase.Organisation.SectorType;
return(result);
}
// populate with return from db
result.ReturnId = returnFromDatabase.ReturnId;
result.OrganisationId = returnFromDatabase.OrganisationId;
result.EncryptedOrganisationId = returnFromDatabase.Organisation.GetEncryptedId();
result.DiffMeanBonusPercent = returnFromDatabase.DiffMeanBonusPercent;
result.DiffMeanHourlyPayPercent = returnFromDatabase.DiffMeanHourlyPayPercent;
result.DiffMedianBonusPercent = returnFromDatabase.DiffMedianBonusPercent;
result.DiffMedianHourlyPercent = returnFromDatabase.DiffMedianHourlyPercent;
result.FemaleLowerPayBand = returnFromDatabase.FemaleLowerPayBand;
result.FemaleMedianBonusPayPercent = returnFromDatabase.FemaleMedianBonusPayPercent;
result.FemaleMiddlePayBand = returnFromDatabase.FemaleMiddlePayBand;
result.FemaleUpperPayBand = returnFromDatabase.FemaleUpperPayBand;
result.FemaleUpperQuartilePayBand = returnFromDatabase.FemaleUpperQuartilePayBand;
result.MaleLowerPayBand = returnFromDatabase.MaleLowerPayBand;
result.MaleMedianBonusPayPercent = returnFromDatabase.MaleMedianBonusPayPercent;
result.MaleMiddlePayBand = returnFromDatabase.MaleMiddlePayBand;
result.MaleUpperPayBand = returnFromDatabase.MaleUpperPayBand;
result.MaleUpperQuartilePayBand = returnFromDatabase.MaleUpperQuartilePayBand;
result.JobTitle = returnFromDatabase.JobTitle;
result.FirstName = returnFromDatabase.FirstName;
result.LastName = returnFromDatabase.LastName;
result.CompanyLinkToGPGInfo = returnFromDatabase.CompanyLinkToGPGInfo;
result.AccountingDate = returnFromDatabase.AccountingDate;
result.OrganisationSize = returnFromDatabase.OrganisationSize;
result.SectorType = returnFromDatabase.Organisation.SectorType;
result.FormatDecimals();
result.Modified = returnFromDatabase.Modified;
//result.LatestOrganisationName = returnFromDatabase.LatestOrganisation?.OrganisationName;
result.OrganisationName = returnFromDatabase.Organisation.OrganisationName;
result.LateReason = returnFromDatabase.LateReason;
result.EHRCResponse = returnFromDatabase.EHRCResponse.ToString();
result.OptedOutOfReportingPayQuarters = returnFromDatabase.OptedOutOfReportingPayQuarters;
// set the report info
result.ReportInfo = await GetReportInfoModelWithDraftAsync(
returnFromDatabase.Organisation,
returnFromDatabase.Modified,
snapshotYear,
userId);
if (result.ReportInfo?.Draft?.ReturnViewModelContent != null)
{
Draft temporaryDraft = result.ReportInfo.Draft;
result = result.ReportInfo.Draft.ReturnViewModelContent;
result.ReportInfo.Draft = temporaryDraft;
}
return(result);
}
public Draft Get(int draftId)
{
Draft draft = _context.Drafts.Find(draftId);
return(draft);
}
public Task SaveAsync(Draft draft)
{
return SaveAsync(draft, CancellationToken.None);
}
//private bool HasReturnViewModelChanged(Draft draftToBackup, ReturnViewModel postedReturnViewModel)
//{
// if (!_fileRepository.GetFileExists(draftToBackup.DraftPath))
// return false;
// var storedReturnViewModel = DeserialiseDraftContent(draftToBackup.DraftPath);
// if (!postedReturnViewModel.HasUserData())
// return false;
// return !postedReturnViewModel.AreDraftFieldsEqual(storedReturnViewModel);
//}
public async Task DiscardDraftAsync(Draft draftToDiscard)
{
await CheckBeforeDeleteAsync(draftToDiscard.DraftPath);
await CheckBeforeDeleteAsync(draftToDiscard.BackupDraftPath);
}
public IActionResult DeleteDraft(Draft Draft)
{
var postResult = Helper.PostValueToSevice <Draft>("Delete?id=" + Draft.Id.ToString(), Draft);
return(Json(new { success = postResult.result, message = postResult.message }));
}
public async Task CommitDraftAsync(Draft draftToDiscard)
{
await SetMetadataAsync(draftToDiscard, 0);
await CheckBeforeDeleteAsync(draftToDiscard.BackupDraftPath);
}
public Draft PutDraft(Draft draft)
{
throw new NotImplementedException();
}
private async Task GetDraftAccessInformationAsync(long userRequestingAccessToDraft, Draft draft)
{
draft.LastWrittenDateTime = await CheckBeforeGetLastWriteTimeAsync(draft.DraftPath);
var result = await GetIsUserAllowedAccessAsync(userRequestingAccessToDraft, draft);
draft.IsUserAllowedAccess = result.IsAllowedAccess;
draft.LastWrittenByUserId = result.UserId;
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
/// <param name="baseCampaignId">Id of the campaign to use as base of the
/// draft.</param>
public void Run(AdWordsUser user, long baseCampaignId)
{
using (DraftService draftService =
(DraftService)user.GetService(AdWordsService.v201802.DraftService))
using (CampaignCriterionService campaignCriterionService =
(CampaignCriterionService)user.GetService(AdWordsService.v201802
.CampaignCriterionService))
{
Draft draft = new Draft()
{
baseCampaignId = baseCampaignId,
draftName = "Test Draft #" + ExampleUtilities.GetRandomString()
};
DraftOperation draftOperation = new DraftOperation()
{
@operator = Operator.ADD,
operand = draft
};
try
{
draft = draftService.mutate(new DraftOperation[]
{
draftOperation
}).value[0];
Console.WriteLine(
"Draft with ID {0}, base campaign ID {1} and draft campaign ID " +
"{2} created.", draft.draftId, draft.baseCampaignId,
draft.draftCampaignId);
// Once the draft is created, you can modify the draft campaign as if it
// were a real campaign. For example, you may add criteria, adjust bids,
// or even include additional ads. Adding a criterion is shown here.
Language language = new Language()
{
id = 1003L // Spanish
};
// Make sure to use the draftCampaignId when modifying the virtual draft
// campaign.
CampaignCriterion campaignCriterion = new CampaignCriterion()
{
campaignId = draft.draftCampaignId,
criterion = language
};
CampaignCriterionOperation criterionOperation =
new CampaignCriterionOperation()
{
@operator = Operator.ADD,
operand = campaignCriterion
};
campaignCriterion = campaignCriterionService.mutate(
new CampaignCriterionOperation[]
{
criterionOperation
}).value[0];
Console.WriteLine(
"Draft updated to include criteria in draft campaign ID {0}.",
draft.draftCampaignId);
}
catch (Exception e)
{
throw new System.ApplicationException(
"Failed to create draft campaign and add " + "criteria.", e);
}
}
}
public Draft ToEntity()
{
var draft = new Draft
{
Id = Id,
Title = Title,
Body = Body,
Type = Type,
ItemIsPublic = ItemIsPublic,
ItemCreatedDateTime = ItemCreatedDateTime,
ItemRevisionCount = ItemRevisionCount,
LastModifiedDateTime = LastModifiedDateTime,
Comment = Comment,
CurrentRevisionNo = CurrentRevisionNo,
};
if (!string.IsNullOrWhiteSpace(Author))
{
var xmlAuthor = new XmlDocument();
xmlAuthor.LoadXml(Author);
var jsonAuthor = Regex.Replace(JsonConvert.SerializeXmlNode(xmlAuthor), "(?<=\")(@)(?!.*\":\\s )", "",
RegexOptions.IgnoreCase);
var jObjectAuthor = JObject.Parse(jsonAuthor)["Author"];
var author = JsonConvert.DeserializeObject<User>(jObjectAuthor.ToString());
draft.Author = author;
}
else
{
draft.Author = User.Unknown;
}
if (string.IsNullOrWhiteSpace(Tags)) return draft;
var xmlTags = new XmlDocument();
xmlTags.LoadXml(Tags);
var jsonTags = Regex.Replace(JsonConvert.SerializeXmlNode(xmlTags), "(?<=\")(@)(?!.*\":\\s )", "", RegexOptions.IgnoreCase);
var jObjectTags = JObject.Parse(jsonTags)["Tags"]["Tag"];
if (jObjectTags.Type == JTokenType.Array)
{
var tags = JsonConvert.DeserializeObject<IEnumerable<ItemTag>>(jObjectTags.ToString());
foreach (var tag in tags)
{
draft.ItemTags.Add(tag);
}
}
else
{
var tag = JsonConvert.DeserializeObject<ItemTag>(jObjectTags.ToString());
draft.ItemTags.Add(tag);
}
return draft;
}
