public void GuaranteeThis()
{
var data = new List <int>();
Guarantee.This(() => true);
Assert.Throws <Exception>(() => Guarantee.This(() => false));
}
public GuaranteeViewForm(Guarantee guarantee, bool enableConfirmation)
{
_guarantee = guarantee;
_enableConfirmation = enableConfirmation;
InitializeComponent();
}
public void GuaranteeThisGeneric()
{
var data = new List <int>();
Guarantee.This((lst) => lst.Count == 0, data);
Assert.Throws <Exception>(() => Guarantee.This((lst) => lst.Count == 1, data));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Icon,Title,HasDeleted,DeletedTime")] Guarantee guarantee)
{
if (id != guarantee.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(guarantee);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GuaranteeExists(guarantee.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(guarantee));
}
/// <summary>
/// Adds the given guarantee.
/// </summary>
public void AddGuarantee(Guarantee guarantee)
{
Debug.Assert(guarantee != null);
Debug.Assert(!_guarantees.Contains(guarantee));
_guarantees.Add(guarantee);
}
/// <summary>
/// 获取EasyUiDataGrid数据集
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public EasyUiDataGrid <Guarantee> GetEasyUiDataList(Guarantee entity, int pageIndex, int pageSize, string order)
{
return(new EasyUiDataGrid <Guarantee>()
{
Total = GetRecordCount(entity),
Rows = GetList(entity, pageIndex, pageSize, order)
});
}
public ActionResult Edit([Bind(Include = "Id,creationDate,expirationDate,status")] Guarantee guarantee)
{
if (ModelState.IsValid)
{
db.Entry(guarantee).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(guarantee));
}
public async Task <IActionResult> Create([Bind("Id,Icon,Title,HasDeleted,DeletedTime")] Guarantee guarantee)
{
if (ModelState.IsValid)
{
_context.Add(guarantee);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(guarantee));
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public List <Guarantee> GetList(Guarantee entity)
{
StringBuilder sql = new StringBuilder($" SELECT * FROM [dbo].[{tableName}] ");
Dictionary <string, object> parameters = new Dictionary <string, object>();
LoadCondition(entity, sql, ref parameters);
return(DataHelper.GetList <Guarantee>(db, sql.ToString(), parameters, delegate(IDataReader reader, Guarantee dataModel)
{
BuildTenant(reader, dataModel);
}));
}
public ActionResult Create([Bind(Include = "Id,creationDate,expirationDate,status")] Guarantee guarantee)
{
if (ModelState.IsValid)
{
db.Guarantees.Add(guarantee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(guarantee));
}
/// <summary>
/// 根据条件获取
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public Guarantee Get(Guarantee searchEntity)
{
var list = GuaranteeDao.Instance.GetList(searchEntity);
if (list != null && list.Count > 0)
{
return(list[0]);
}
else
{
return(null);
}
}
public void Init(IClient client, Loan loan, Guarantee guarantee, SavingBookContract savings, IList <IPrintButtonContextMenuStrip> printMenus)
{
_printButton.AttachmentPoint = AttachmentPoint.CreditCommittee;
Visibility visibility;
switch (client.Type)
{
case OClientTypes.Person:
visibility = Visibility.Individual;
break;
case OClientTypes.Group:
visibility = Visibility.Group;
break;
case OClientTypes.Corporate:
visibility = Visibility.Corporate;
break;
default:
visibility = Visibility.All;
break;
}
_printButton.Visibility = visibility;
_printButton.ReportInitializer =
report =>
{
report.SetExtra("loan", loan);
report.SetParamValue("user_id", User.CurrentUser.Id);
if (loan != null)
{
report.SetParamValue("contract_id", loan.Id);
}
};
_printButton.LoadReports();
foreach (var item in printMenus)
{
var menuItems = item.GetContextMenuStrip(client, loan, guarantee, savings, AttachmentPoint.CreditCommittee.ToString());
if (menuItems == null)
{
continue;
}
foreach (var menuItem in menuItems)
{
_printButton.Menu.Items.Add(menuItem);
}
}
}
/// <summary>
/// 映射
/// </summary>
/// <param name="reader"></param>
/// <param name="entity"></param>
private void BuildTenant(IDataReader reader, Guarantee entity)
{
entity.Id = reader.GetValue <Guid>("Id");
entity.TenantId = reader.GetValue <Guid>("TenantId");
entity.CreateBy = reader.GetValue <Guid>("CreateBy");
entity.CreateTime = reader.GetValue <DateTime>("CreateTime");
entity.ModifyBy = reader.GetValue <Guid>("ModifyBy");
entity.ModifyTime = reader.GetValue <DateTime>("ModifyTime");
entity.EquipmentId = reader.GetValue <Guid>("EquipmentId");
entity.Remark = reader.GetValue <string>("Remark");
entity.StartDateTime = reader.GetValue <DateTime>("StartDateTime");
entity.EndDateTime = reader.GetValue <DateTime>("EndDateTime");
entity.ComponentId = reader.GetValue <Guid>("ComponentId");
}
// GET: Guarantees/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Guarantee guarantee = db.Guarantees.Find(id);
if (guarantee == null)
{
return(HttpNotFound());
}
return(View(guarantee));
}
/// <summary>
/// This constructor assumes authorization.
/// </summary>
/// <param name="api">Authorized <see cref="VkApi" /></param>
/// <param name="maxAudioPerRequest">Max count of tracks per one request. Should be less than 6k and more than 0</param>
public VkMusicDownloadEngine(VkApi api, uint maxAudioPerRequest)
{
Guarantee.IsArgumentNotNull(api, nameof(api));
Guarantee.IsGreaterThan(maxAudioPerRequest, 0, nameof(maxAudioPerRequest));
Guarantee.IsLessOrEqual(maxAudioPerRequest, 6000, nameof(maxAudioPerRequest));
if (!api.IsAuthorized)
{
throw new ArgumentException("API has to be authorized.", nameof(api));
}
_api = api;
_maxAudioPerRequest = maxAudioPerRequest;
}
internal static OperationExecutedDto AddGuarantee(Guarantee guarantee)
{
try
{
guarantee = _bankGuaranteeContext.Guarantees.Add(guarantee);
_bankGuaranteeContext.SaveChanges();
}
catch (Exception ex)
{
return(new OperationExecutedDto(Resources.DatabaseError + ex.Message));
}
_guaranteeCreator.OnCreated(new EntityCreatedDto(guarantee.Id, guarantee.Name));
return(OperationExecutedDto.Success);
}
/// <summary>
/// 加载条件
/// </summary>
/// <param name="entity">查询实体</param>
/// <param name="sql">SQL命令</param>
/// <param name="parameters">参数</param>
private void LoadCondition(Guarantee entity, StringBuilder sql, ref Dictionary <string, object> parameters)
{
if (entity == null)
{
return;
}
sql.AppendFormat(" WHERE 1=1 ");
if (entity.Id != Guid.Empty)
{
sql.AppendFormat(" AND [Id]=@Id ");
parameters.Add("@Id", entity.Id);
}
if (entity.TenantId != Guid.Empty)
{
sql.AppendFormat(" AND [TenantId]=@TenantId ");
parameters.Add("@TenantId", entity.TenantId);
}
if (entity.CreateBy != Guid.Empty)
{
sql.AppendFormat(" AND [CreateBy]=@CreateBy ");
parameters.Add("@CreateBy", entity.CreateBy);
}
if (entity.ModifyBy != Guid.Empty)
{
sql.AppendFormat(" AND [ModifyBy]=@ModifyBy ");
parameters.Add("@ModifyBy", entity.ModifyBy);
}
if (entity.EquipmentId != Guid.Empty)
{
sql.AppendFormat(" AND [EquipmentId]=@EquipmentId ");
parameters.Add("@EquipmentId", entity.EquipmentId);
}
if (!string.IsNullOrWhiteSpace(entity.Remark))
{
sql.AppendFormat(" AND [Remark]=@Remark ");
parameters.Add("@Remark", entity.Remark);
}
if (entity.ComponentId != Guid.Empty)
{
sql.AppendFormat(" AND [ComponentId]=@ComponentId ");
parameters.Add("@ComponentId", entity.ComponentId);
}
}
public async Task Enqueue(QueueElement queueElement)
{
Guarantee.IsArgumentNotNull(queueElement, nameof(queueElement));
Guarantee.IsArgumentNotNull(queueElement, nameof(queueElement.TaskGenerator));
await _semaphore.WaitAsync();
try
{
await queueElement.TaskGenerator();
}
finally
{
_semaphore.Release();
}
}
void ParseGuaranteesElement(XElement guaranteesElement)
{
//Iterate through all elements.
IEnumerable <XElement> elements = guaranteesElement.Elements();
foreach (XElement element in elements)
{
Guarantee guarantee = null;
//Handle guarantee element.
GuaranteeTypes guranteeType;
if (Enum.TryParse <GuaranteeTypes>(element.Name.LocalName, out guranteeType))
{
switch (guranteeType)
{
case GuaranteeTypes.WeaponSetting:
guarantee = CreateWeaponSettingGuarantee(element);
break;
case GuaranteeTypes.GodWormsIndyTerrainExclusivity:
guarantee = new GodWormsIndyTerrainExclusivityGuarantee();
break;
case GuaranteeTypes.WeaponsPerFunctionKey:
guarantee = new WeaponsPerFunctionKeyGuarantee(CreateValueGenerator(element));
break;
default:
_errorCollection.AddInvalidElement(element);
break;
}
}
//Invalid element.
else
{
_errorCollection.AddInvalidElement(element);
}
if (guarantee != null)
{
_schemeGenerator.AddGuarantee(guarantee);
}
}
}
/// <summary>
/// Async searching of similar tracks on spotify via default track model.
/// </summary>
/// <param name="tracks">Tracks models</param>
/// <param name="ct">Cancellation token.</param>
/// <param name="progress">Callback to inform about current progress.</param>
/// <returns>Dictionary of default models and spotify tracks.</returns>
public async Task <IEnumerable <SpotifyTrack> > FindTracksPairsAsync(IEnumerable <TIn> tracks,
CancellationToken ct, Action <float> progress = null)
{
Guarantee.IsEnumerableNotNullOrEmpty(tracks, nameof(tracks));
var songPairs = new List <SpotifyTrack>();
try
{
//to avoid enumeration if it isn't necessary
var tracksCount = progress == null ? 0 : tracks.Count();
var processed = 0;
foreach (var track in tracks)
{
ct.ThrowIfCancellationRequested();
SpotifyTrack spotifyTrack;
try
{
spotifyTrack = await FindTrackPairAsync(track, new CancellationToken());
}
catch (APITooManyRequestsException tooManyRequestsException)
{
await Task.Delay(tooManyRequestsException.RetryAfter + TimeSpan.FromSeconds(1), ct);
spotifyTrack = await FindTrackPairAsync(track, new CancellationToken());
}
if (spotifyTrack != null)
{
songPairs.Add(spotifyTrack);
}
progress?.Invoke(100f / tracksCount * ++processed);
}
return(songPairs);
}
catch
{
return(songPairs);
}
}
/// <summary>
/// Async searching of the similar track on spotify via default track model.
/// </summary>
/// <param name="track">Track model</param>
/// <param name="ct">Cancellation token.</param>
/// <returns>Spotify track info.</returns>
public async Task <SpotifyTrack> FindTrackPairAsync(TIn track, CancellationToken ct)
{
ct.ThrowIfCancellationRequested();
Guarantee.IsArgumentNotNull(track, nameof(track));
var taskResult = await _client.Search.Item(
new SearchRequest(SearchRequest.Types.Track, $"{track.Artist} {track.Title}")
{
Limit = 1
});
if (taskResult.Tracks.Items != null && taskResult.Tracks.Items.Any())
{
return((SpotifyTrack)taskResult.Tracks.Items.FirstOrDefault());
}
return(null);
}
/// <summary>
/// 创建
/// </summary>
/// <param name="entity"></param>
public void Create(Guarantee entity)
{
var fields = new Dictionary <string, object>()
{
{ "Id", entity.Id },
{ "TenantId", entity.TenantId },
{ "CreateBy", entity.CreateBy },
{ "CreateTime", entity.CreateTime },
{ "ModifyBy", entity.ModifyBy },
{ "ModifyTime", entity.ModifyTime },
{ "EquipmentId", entity.EquipmentId },
{ "Remark", entity.Remark },
{ "StartDateTime", entity.StartDateTime },
{ "EndDateTime", entity.EndDateTime },
{ "ComponentId", entity.ComponentId }
};
DataHelper.Add(db, tableName, fields);
}
/// <summary>
/// Gets track list of specified user.
/// </summary>
/// <param name="user">User of Vk.</param>
/// <returns>Collection of <see cref="VkTrack" /></returns>
public IEnumerable <VkTrack> DownloadTrackList(User user)
{
Guarantee.IsArgumentNotNull(user, nameof(user));
var tracksCount = _api.Audio.GetCount(user.Id);
if (tracksCount <= 0)
{
return(null);
}
if (tracksCount > _maxAudioPerRequest)
{
var tracksList = new List <VkTrack>();
for (uint songListOffset = 0; songListOffset < tracksCount; songListOffset += _maxAudioPerRequest)
{
var vkAudioCollection = _api.Audio.Get(new AudioGetParams
{
OwnerId = user.Id,
Offset = songListOffset,
Count = _maxAudioPerRequest
});
tracksList.AddRange(vkAudioCollection.Select(t => (VkTrack)t));
}
return(tracksList);
}
else
{
var vkAudioCollection = _api.Audio.Get(new AudioGetParams
{
OwnerId = user.Id,
Count = tracksCount
});
return(vkAudioCollection.Select(t => (VkTrack)t));
}
}
/// <summary>
/// Async saving of tracks into the library of user.
/// </summary>
/// <param name="spotifyTracks">Spotify tracks which is gonna be added.</param>
/// <param name="ct">Token to cancel.</param>
/// <returns></returns>
public async Task <bool> SaveTracksAsync(IEnumerable <SpotifyTrack> spotifyTracks, CancellationToken ct)
{
Guarantee.IsEnumerableNotNullOrEmpty(spotifyTracks, nameof(spotifyTracks));
foreach (var list in CommonUtils.SplitOnLists(spotifyTracks, 50))
{
ct.ThrowIfCancellationRequested();
try
{
return(await SaveTracks(list));
}
catch (APITooManyRequestsException tooManyRequestsException)
{
await Task.Delay(tooManyRequestsException.RetryAfter + TimeSpan.FromSeconds(1), ct);
return(await SaveTracks(list));
}
}
return(true);
}
public JsonResult Save(Guarantee entity)
{
entity.TenantId = this.TenantId;
if (entity.Id == Guid.Empty)
{
entity.Id = Guid.NewGuid();
entity.CreateBy = this.UserId;
entity.CreateTime = DateTime.Now;
entity.ModifyBy = this.UserId;
entity.ModifyTime = DateTime.Now;
GuaranteeProvider.Instance.Create(entity);
}
else
{
entity.ModifyBy = this.UserId;
entity.ModifyTime = DateTime.Now;
GuaranteeProvider.Instance.Update(entity);
}
return(Json(new ResponseModel()
{
Status = true
}));
}
public void AddGuarantee(Guarantee pGuarantee, OClientTypes pClientType)
{
pGuarantee.ClientType = pClientType;
pGuarantee.Project = this;
_guarantees.Add(pGuarantee);
}
public SpotifySearchEngine(SpotifyClient client)
{
Guarantee.IsArgumentNotNull(client, nameof(client));
_client = client;
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public List <Guarantee> GetList(Guarantee entity)
{
return(GuaranteeDao.Instance.GetList(entity));
}
/// <summary>
/// 创建
/// </summary>
/// <param name="entity"></param>
public void Create(Guarantee entity)
{
GuaranteeDao.Instance.Create(entity);
}
/// <summary>
/// 更新
/// </summary>
/// <param name="entity"></param>
public void Update(Guarantee entity)
{
GuaranteeDao.Instance.Update(entity);
}
/// <summary>
/// 获取记录总数
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public int GetRecordCount(Guarantee searchEntity)
{
var list = GetList(searchEntity);
return(list == null ? 0 : list.Count);
}
