public async Task <TagUse> RenameTagUseAsync(RenameTagUseRequest request)
{
SystemContract.RequireNotNullOrWhiteSpace(request.NewName, "request.NewName");
SystemContract.RequireNotNullOrWhiteSpace(request.OldName, "request.OldName");
/// NewNameの使用確認
var newNameTagUseQuery = _refsContext.TagUses.Include("Owner").AsNoTracking().
Where(u => u.OwnerId == request.OwnerId && u.Name == request.NewName);
/// collationをcase insensitiveにしているので大文字小文字が異なるTagUseも取得される
var newNameTagUses = await newNameTagUseQuery.ToArrayAsync();
var isNewNameTagUseExists = newNameTagUses.Any(u => u.Name == request.NewName);
BusinessContract.Require(!isNewNameTagUseExists, Errors.TagUseNameAlreadyExists, request.NewName);
var oldNameTagUseQuery = _refsContext.TagUses.Include("Owner").
Where(t => t.OwnerId == request.OwnerId && t.Name == request.OldName);
/// collationをcase insensitiveにしているので大文字小文字が異なるTagUseも取得される
var storedTagUses = await oldNameTagUseQuery.ToArrayAsync();
var storedTagUse = storedTagUses.Single(u => u.Name == request.OldName);
BusinessContract.ValidateWritePermission(request.OwnerId);
BusinessContract.ValidateRowVersion(request.TagUseIdentity.RowVersion, storedTagUse.RowVersion);
var tag = await EnsureTagAsync(request.NewName);
storedTagUse.TagId = tag.Id;
storedTagUse.Name = request.NewName;
_refsContext.MarkAsModified(storedTagUse);
await _refsContext.SaveChangesAsync();
return(storedTagUse);
}
public async Task <EntityIdentity> MoveRefAsync(EntityIdentity identity, int oldIndex, int newIndex)
{
if (newIndex == oldIndex)
{
return(identity);
}
var query =
from l in _refsContext.RefLists.Include("Refs")
where l.Id == identity.Id
select l;
var storedRefList = await query.SingleOrDefaultAsync();
BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
BusinessContract.ValidateRowVersion(storedRefList.RowVersion, identity.RowVersion);
var refs = storedRefList.Refs.OrderBy(r => r.DisplayOrder).ToList();
var moving = refs[oldIndex];
refs.RemoveAt(oldIndex);
refs.Insert(newIndex, moving);
for (int i = 0; i < refs.Count; ++i)
{
refs[i].DisplayOrder = i;
}
_refsContext.MarkAsModified(storedRefList);
await _refsContext.SaveChangesAsync();
SendRefListUpdated(identity.Id);
identity.RowVersion = storedRefList.RowVersion;
return(identity);
}
public async Task <ActionResult> AddByBookmarklet(string url)
{
/// bindするとvalidateで「<」とか「>」とかがだめになる
var title = Request.Unvalidated.QueryString["title"];
SystemContract.RequireNotNullOrWhiteSpace(url, "url");
BusinessContract.Require(url.Length <= WebConsts.MaxRefLinkUrlLength, Errors.UrlTooLong);
if (!string.IsNullOrWhiteSpace(title) && title.Length > WebConsts.MaxRefLinkTitleLength)
{
title = title.Substring(0, WebConsts.MaxRefLinkTitleLength);
}
var model = new AddByBookmarkletPageViewModel()
{
Uri = url,
Title = title,
};
var user = GetUser();
var req = new GetRefListsRequest(
user.Id, null, null, null, "", null, PublishingStatusConditionKind.All, 0, 500, RefListSortKind.UpdatedDateDescending
);
var resp = await _refListHandler.GetRefListsAsync(req);
model.RefLists = Mapper.Map <ICollection <RefListViewModel> >(resp.RefLists);
return(View(model));
}
/// <summary>
/// refListIdのRefListにrefeを追加します。
/// bookmarkletから呼ばれ、呼出し後はリダイレクトされるのでRowVersionのことは考えなくてよい。
/// </summary>
public async Task AddRefWithoutRowVersionAsync(long refListId, Ref refe)
{
var query =
from l in _refsContext.RefLists.Include("Refs")
where l.Id == refListId
select l;
var storedRefList = await query.SingleAsync();
BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
refe.DisplayOrder = storedRefList.Refs.Count;
refe.RefListId = 0;
refe.RefList = null;
storedRefList.Refs.Add(refe);
/// update statistics
if (refe.Kind == RefKind.Link)
{
var statisticsQuery = _refsContext.RefListStatistics.Where(s => s.RefListId == refListId);
var storedStatistics = await statisticsQuery.SingleAsync();
storedStatistics.LinkCount = storedRefList.Refs.Count(r => r.Kind == RefKind.Link);
}
_refsContext.MarkAsModified(storedRefList);
await _refsContext.SaveChangesAsync();
SendRefListUpdated(refListId);
}
protected BusinessTransaction Map(IUserSettings userSettings, IProduct product, ApiTransactionSet transaction, ApiPerformance performance)
{
var businessTransaction = new BusinessTransaction()
{
Hash = transaction.Hash,
ContractAddress = product.Token.Address,
BlockNumber = transaction.BlockNumber,
Confirmations = transaction.Confirmations,
ConfirmedAt = transaction.ConfirmedAt,
Success = transaction.Success,
Eth = transaction.Eth,
Gas = transaction.Gas,
GasLimit = transaction.GasLimit,
GasUsed = transaction.GasUsed,
Sender = transaction.Sender,
Recipient = transaction.Recipient,
Price = performance != null
? new BusinessPrice()
{
MarketValuePerToken = performance.MarketValuePerToken,
NetAssetValuePerToken = performance.NetAssetValuePerToken
}
: null,
Operations = transaction.Operations
.Select(operation => new BusinessOperation()
{
IsEth = operation.IsEth,
Sender = operation.Sender,
Address = operation.Address,
PricePerToken =
performance != null &&
operation.PricePerToken == default &&
operation.Contract.Symbol.Equals(product.Token.Symbol.ToString(), StringComparison.OrdinalIgnoreCase)
? performance.MarketValuePerToken ?? performance.NetAssetValuePerToken
: operation.PricePerToken,
Priority = operation.Priority,
Quantity = operation.Quantity,
Type = operation.Type,
Value = operation.Value,
Recipient = operation.Recipient,
TransferAction = GetOperationTransferAction(operation),
Contract = new BusinessContract()
{
Symbol = operation.Contract.Symbol,
Address = operation.Contract.Address,
Decimals = operation.Contract.Decimals,
Holders = operation.Contract.Holders,
Issuances = operation.Contract.Issuances,
Name = operation.Contract.Name,
Link = operation.Contract.Links.Link,
ImageLink = operation.Contract.Links.ImageLink,
MarketLink = operation.Contract.Links.MarketLink
}
})
public async Task <AddRefResponse> AddRefAsync(EntityIdentity refListIdentity, int refIndex, Ref refe)
{
var query =
from l in _refsContext.RefLists.Include("Refs")
where l.Id == refListIdentity.Id
select l;
var storedRefList = await query.SingleAsync();
BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
BusinessContract.ValidateRowVersion(storedRefList.RowVersion, refListIdentity.RowVersion);
refe.RefListId = 0;
refe.RefList = null;
var refs = storedRefList.Refs.OrderBy(r => r.DisplayOrder).ToList();
refs.Insert(refIndex, refe);
for (int i = 0; i < refs.Count; ++i)
{
refs[i].DisplayOrder = i;
}
storedRefList.Refs.Add(refe);
/// update statistics
if (refe.Kind == RefKind.Link)
{
var statisticsQuery = _refsContext.RefListStatistics.Where(s => s.RefListId == refListIdentity.Id);
var storedStatistics = await statisticsQuery.SingleAsync();
storedStatistics.LinkCount = storedRefList.Refs.Count(r => r.Kind == RefKind.Link);
}
_refsContext.MarkAsModified(storedRefList);
await _refsContext.SaveChangesAsync();
SendRefListUpdated(refListIdentity.Id);
var ret = new AddRefResponse()
{
RefListIdentity = new EntityIdentity(storedRefList.Id, storedRefList.RowVersion),
RefId = refe.Id,
};
return(ret);
}
public async Task RemoveTagUsesAsync(EntityIdentity identity)
{
SystemContract.RequireEntityIdentity(identity);
var query = _refsContext.TagUses.Include("RefLists").
Where(t => t.Id == identity.Id);
var storedTagUse = await query.SingleAsync();
BusinessContract.ValidateRowVersion(storedTagUse.RowVersion, identity.RowVersion);
BusinessContract.ValidateWritePermission(storedTagUse.OwnerId);
storedTagUse.RefLists.Clear();
_refsContext.TagUses.Remove(storedTagUse);
await _refsContext.SaveChangesAsync();
}
public async Task <EntityIdentity> UpdateRefAsync(EntityIdentity identity, Ref updatedRef)
{
var query =
from r in _refsContext.Refs.Include("RefList")
where r.Id == updatedRef.Id
select r;
var storedRef = await query.SingleAsync();
if (storedRef.RefListId != identity.Id)
{
throw new ArgumentException("リストのIdが正しくありません");
}
BusinessContract.ValidateWritePermission(storedRef.RefList.AuthorId);
BusinessContract.ValidateRowVersion(storedRef.RefList.RowVersion, identity.RowVersion);
switch (updatedRef.Kind)
{
case RefKind.Link:
storedRef.Uri = updatedRef.Uri;
storedRef.Title = updatedRef.Title;
storedRef.Comment = updatedRef.Comment;
break;
case RefKind.Heading:
storedRef.Title = updatedRef.Title;
break;
case RefKind.Text:
storedRef.Comment = updatedRef.Comment;
break;
}
if (_refsContext.IsModified(storedRef))
{
_refsContext.MarkAsModified(storedRef.RefList);
}
await _refsContext.SaveChangesAsync();
SendRefListUpdated(identity.Id);
identity.RowVersion = storedRef.RefList.RowVersion;
return(identity);
}
public async Task <ActionResult> Detail(string userName, string titleSearch = "", string tag = null)
{
if (string.IsNullOrWhiteSpace(userName))
{
return(RedirectToAction("Index", "User"));
}
var author = await _UserHandler.GetUserByUserNameAsync(userName);
BusinessContract.Require(author != null, Errors.UserNotFound, userName);
/// 非公開設定の確認のため本人でもPublishしか見れないようにする。
var req = new GetRefListsRequest(
author.Id, null, null, tag, titleSearch, null, PublishingStatusConditionKind.PublishOnly, 0, WebConsts.RefListsPageSize,
RefListSortKind.PublishedDateDescending
);
var result = await _refListHandler.GetRefListsAsync(req);
var tagUses = await _tagHandler.GetAllTagUsesAsync(author.Id);
var vm = new DetailPageViewModel()
{
Author = Mapper.Map <UserViewModel>(author),
OwnedTagUses = Mapper.Map <ICollection <TagUseViewModel> >(tagUses),
TitleSearch = titleSearch,
TagUse = tag,
PageIndex = result.PageIndex + 1,
PageCount = result.PageCount,
RefLists = Mapper.Map <ICollection <RefListViewModel> >(result.RefLists),
};
var isFavored = false;
if (IsAuthenticated())
{
var user = GetUser();
isFavored = await _favoriteHandler.ExistsFavoriteUserAsync(user.Id, author.Id);
}
vm.IsFavored = isFavored;
return(View(vm));
}
//public async Task<RefList> CreateUnfiledRefListAsync(long userId)
//{
// var user = await _userHandler.GetUserAsync(userId);
// _refsContext.Users.Attach(user);
// var refList = new RefList()
// {
// Kind = RefListKind.Unfiled,
// Author = user,
// Title = "unfiled",
// Comment = "",
// PublishingStatus = PublishingStatusKind.Private,
// Refs = new Ref[0],
// Statistics = null,
// };
// _refsContext.RefLists.Add(refList);
// await _refsContext.SaveChangesAsync();
// return refList;
//}
public async Task RemoveRefListAsync(EntityIdentity refListIdentity)
{
var query = _refsContext.RefLists.Include("TagUses").Where(l => l.Id == refListIdentity.Id);
var storedRefList = await query.SingleAsync();
BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
BusinessContract.ValidateRowVersion(storedRefList.RowVersion, refListIdentity.RowVersion);
storedRefList.TagUses.Clear();
foreach (var fav in storedRefList.FavoringFavorites.ToArray())
{
_refsContext.Favorites.Remove(fav);
}
_refsContext.RefListStatistics.Remove(storedRefList.Statistics);
_refsContext.RefLists.Remove(storedRefList);
await _refsContext.SaveChangesAsync();
SendRefListUpdated(refListIdentity.Id);
}
public async Task <EntityIdentity> RemoveRefAsync(EntityIdentity refListIdentity, int refIndex)
{
var query =
from l in _refsContext.RefLists.Include("Refs")
where l.Id == refListIdentity.Id
select l;
var storedRefList = await query.SingleOrDefaultAsync();
BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
BusinessContract.ValidateRowVersion(storedRefList.RowVersion, refListIdentity.RowVersion);
var refs = storedRefList.Refs.OrderBy(r => r.DisplayOrder).ToList();
var removing = refs[refIndex];
refs.RemoveAt(refIndex);
for (int i = 0; i < refs.Count; ++i)
{
refs[i].DisplayOrder = i;
}
_refsContext.Refs.Remove(removing);
/// update statistics
if (removing.Kind == RefKind.Link)
{
var statisticsQuery = _refsContext.RefListStatistics.Where(s => s.RefListId == refListIdentity.Id);
var storedStatistics = await statisticsQuery.SingleAsync();
storedStatistics.LinkCount = storedRefList.Refs.Count(r => r.Kind == RefKind.Link);
}
_refsContext.MarkAsModified(storedRefList);
await _refsContext.SaveChangesAsync();
SendRefListUpdated(refListIdentity.Id);
refListIdentity.RowVersion = storedRefList.RowVersion;
return(refListIdentity);
}
public async Task <EntityIdentity> UpdateRefListAsync(UpdateRefListRequest request)
{
var query =
from l in _refsContext.RefLists.Include("TagUses.Tag").Include("TagUses.Statistics")
where l.Id == request.Id
select l;
var storedRefList = await query.SingleOrDefaultAsync();
BusinessContract.ValidateWritePermission(storedRefList.AuthorId);
BusinessContract.ValidateRowVersion(storedRefList.RowVersion, request.RowVersion);
var isPublishingStatusChanged = storedRefList.PublishingStatus != request.PublishingStatus;
var isPublishedInThisTime =
storedRefList.PublishingStatus != PublishingStatusKind.Publish &&
request.PublishingStatus == PublishingStatusKind.Publish;
storedRefList.Title = request.Title;
storedRefList.Comment = request.Comment;
storedRefList.PublishingStatus = request.PublishingStatus;
if (isPublishedInThisTime)
{
storedRefList.PublishedDate = DateTime.Now;
}
await SetTagUsesAsync(storedRefList, request.TagUses, isPublishingStatusChanged);
await _refsContext.SaveChangesAsync();
SendRefListUpdated(request.Id);
return(new EntityIdentity()
{
Id = request.Id,
RowVersion = storedRefList.RowVersion,
});
}
public async Task <EntityIdentity> MoveRefToAsync(
EntityIdentity fromListIdentity, EntityIdentity toListIdentity, int fromRefIndex, int toRefIndex = -1
)
{
using (var tran = _refsContext.BeginTransaction())
{
try
{
SystemContract.Require(
fromRefIndex > -1,
() => new ArgumentOutOfRangeException("fromRefIndex: " + fromRefIndex)
);
var fromQuery = _refsContext.RefLists.Include("Refs").
Where(l => l.Id == fromListIdentity.Id);
var fromStoredRefList = await fromQuery.SingleAsync();
SystemContract.Require(
fromRefIndex < fromStoredRefList.Refs.Count,
() => new ArgumentOutOfRangeException("fromRefIndex: " + fromRefIndex)
);
BusinessContract.ValidateWritePermission(fromStoredRefList.AuthorId);
BusinessContract.ValidateRowVersion(fromStoredRefList.RowVersion, fromListIdentity.RowVersion);
var toQuery = _refsContext.RefLists.Include("Refs").
Where(l => l.Id == toListIdentity.Id);
var toStoredRefList = await toQuery.SingleAsync();
BusinessContract.ValidateWritePermission(toStoredRefList.AuthorId);
BusinessContract.ValidateRowVersion(toStoredRefList.RowVersion, toListIdentity.RowVersion);
/// fromから削除
var fromRefs = fromStoredRefList.Refs.OrderBy(r => r.DisplayOrder).ToList();
var moving = fromRefs[fromRefIndex];
fromRefs.RemoveAt(fromRefIndex);
for (int i = 0; i < fromRefs.Count; ++i)
{
fromRefs[i].DisplayOrder = i;
}
fromStoredRefList.Refs.Remove(moving);
/// toに追加
var toRefs = toStoredRefList.Refs.OrderBy(r => r.DisplayOrder).ToList();
if (toRefIndex < 0)
{
toRefs.Add(moving);
}
else
{
toRefs.Insert(toRefIndex, moving);
}
for (int i = 0; i < toRefs.Count; ++i)
{
toRefs[i].DisplayOrder = i;
}
toStoredRefList.Refs.Add(moving);
_refsContext.MarkAsModified(fromStoredRefList);
await _refsContext.SaveChangesAsync(); // toのUpdatedDateをfromより後にするため早めに書き込む
/// update statistics
if (moving.Kind == RefKind.Link)
{
var fromStatQuery = _refsContext.RefListStatistics.Where(s => s.RefListId == fromListIdentity.Id);
var storedFromStat = await fromStatQuery.SingleAsync();
storedFromStat.LinkCount = fromStoredRefList.Refs.Count(r => r.Kind == RefKind.Link);
var toStatQuery = _refsContext.RefListStatistics.Where(s => s.RefListId == toListIdentity.Id);
var storedToStat = await toStatQuery.SingleAsync();
storedToStat.LinkCount = toStoredRefList.Refs.Count(r => r.Kind == RefKind.Link);
}
_refsContext.MarkAsModified(toStoredRefList);
await _refsContext.SaveChangesAsync(); // toのUpdatedDateをfromより後にするため遅めに書き込む
SendRefListUpdated(fromListIdentity.Id);
SendRefListUpdated(toListIdentity.Id);
fromListIdentity.RowVersion = fromStoredRefList.RowVersion;
tran.Commit();
return(fromListIdentity);
}
catch (Exception)
{
tran.Rollback();
throw;
}
}
}
