public void IsValid()
{
var item = new TagDto(TagCategory.Appointment)
{
Name = Guid.NewGuid().ToString(),
};
Assert.IsTrue(item.IsValid());
}
public AddFolderViewModel()
: base()
{
PluginContext.Host.UserConnected += (sender, e) => this.component = PluginContext.ComponentFactory.GetInstance<IMedicalRecordComponent>();
this.tagToAdd = new TagDto(TagCategory.MedicalRecord);
this.AddFolderCommand = new RelayCommand(() => this.AddFolder(), () => this.CanAddFolder());
}
public void IsInvalid()
{
var item = new TagDto(TagCategory.Appointment)
{
Name = string.Empty,
};
Assert.IsFalse(item.IsValid());
}
private void Add()
{
try
{
var tag = new TagDto(TagCategory.Appointment) { Name = this.Value, };
Component.Create(tag);
this.Close();
PluginContext.Host.WriteStatus(StatusType.Info, Messages.Msg_CategoryAdded);
}
catch (Exception ex) { this.Handle.Error(ex); }
}
private void Add()
{
try
{
this.component.Create(this.Tag);
this.Tag = new TagDto(TagCategory.Doctor);
PluginContext.Host.WriteStatus(StatusType.Info, Messages.Msg_DataSaved);
}
catch (ExistingItemException ex) { this.Handle.Warning(ex, ex.Message); }
catch (Exception ex) { this.Handle.Error(ex, Messages.Msg_ErrorOccured); }
finally { this.Close(); }
}
private void Add()
{
try
{
var tag = new TagDto(TagCategory.Pathology) { Name = this.CategoryName };
Component.Create(tag);
this.Close();
PluginContext.Host.WriteStatus(StatusType.Info, Messages.Msg_CategoryAdded);
this.Close();
}
catch (ExistingItemException ex) { this.Handle.Warning(ex, ex.Message); }
catch (Exception ex)
{
this.Handle.Error(ex);
this.Close();
}
}
public static void SetStamp(DependencyObject target, TagDto value)
{
target.SetValue(StampProperty, value);
}
public TagViewModel()
{
Tag = new TagDto();
IsNew = true;
}
/// <summary>
/// Gets the pictures for the specified patient and with the specified tag.
/// If the specified tag is null, it'll select all the picture of the specified
/// patient
/// </summary>
/// <param name="patient">The patient.</param>
/// <param name="tag">The criteria of the search. If null, it'll take all the picture for the specified patient</param>
/// <returns>
/// A list of pictures
/// </returns>
public IList<PictureDto> GetPictures(LightPatientDto patient, TagDto tag)
{
IList<Picture> pictures = this.GetEntityPictures(patient, tag);
return Mapper.Map<IList<Picture>, IList<PictureDto>>(pictures);
}
public async Task <JsonResult> UpdateTag([FromBody] TagDto vm)
{
await _tagService.UpdateTagAsync(vm);
return(Json(OkReturnString));
}
public TagViewModel(TagDto tag)
{
Tag = tag;
IsNew = false;
}
public long Create(TagDto tag)
{
return new Creator(this.Session).Create(tag);
}
public TagDto Tag(TagDto tagModel)
{
return(this.tagService.CreateTag(tagModel));
}
public void UpdateTag(TagDto tag, int customerID)
{
TagServices.UpdateTag(tag, customerID);
}
public static void SetSpecialisation(DependencyObject target, TagDto value)
{
target.SetValue(SpecialisationProperty, value);
}
public void CreateTag(int customerID, TagDto tag)
{
TagServices.CreateTag(customerID, tag);
}
private (string tagFilterJson, string tagIncludedLoginsJson, string tagExcludedLoginsJson) GetTagAsJson(TagDto dto)
{
var filter = new TagFilterDto();//dto.TagFilter;
var includedLogins = dto.TagFilter.IncludedLogins;
var excludedLogins = dto.TagFilter.ExcludedLogins;
filter.IncludedLogins = new Dictionary <int, List <int> >();
filter.ExcludedLogins = new Dictionary <int, List <int> >();
filter.TagIds = dto.TagFilter.TagIds;
filter.XIds = dto.TagFilter.XIds;
filter.Groups = dto.TagFilter.Groups;
filter.OperatorByCalculation = dto.TagFilter.OperatorByCalculation;
filter.RegulationId = dto.TagFilter.RegulationId;
filter.ServerIds = dto.TagFilter.ServerIds;
var jFilter = JsonConvert.SerializeObject(filter);
var jIncludedLogins = string.Empty;
var jExcludedLogins = string.Empty;
if (includedLogins.Any())
{
jIncludedLogins = JsonConvert.SerializeObject(includedLogins);
}
if (excludedLogins.Any())
{
jExcludedLogins = JsonConvert.SerializeObject(excludedLogins);
}
return(jFilter, jIncludedLogins, jExcludedLogins);
}
private IList<Picture> GetEntityPictures(LightPatientDto patient, TagDto tag)
{
IList<Picture> pictures = new List<Picture>();
// If there's a null criterium, select all the pictures;
// otherwise, execute a search
if (tag == null)
{
pictures = (from p in this.Session.Query<Picture>()
where p.Patient.Id == patient.Id
select p).ToList();
}
else
{
pictures = (from p in this.Session.Query<Picture>()
where p.Patient.Id == patient.Id
&& p.Tag.Id == tag.Id
select p).ToList();
}
return pictures;
}
/// <summary>
/// Create the specified item into the database
/// </summary>
/// <param name="item">The item to add in the database</param>
public long Create(TagDto item)
{
Assert.IsNotNull(item, "item");
Assert.IsNotNull(item.Name, "item.Name");
var exist = (from p in this.Session.Query<Tag>()
where (p.Name.ToUpper() == item.Name.ToUpper()
&& p.Category == item.Category)
|| p.Id == item.Id
select p).ToList().Count() > 0;
if (exist) throw new ExistingItemException();
var entity = Mapper.Map<TagDto, Tag>(item);
item.Id = (long)this.Session.Save(entity);
return item.Id;
}
/// <summary>
/// Gets the doubloons of the specified doctor.
/// </summary>
/// <param name="firstName">The first name of the doctor.</param>
/// <param name="lastName">The last name of the doctor.</param>
/// <param name="specialisation">The specialisation of the doctor.</param>
/// <param name="query">preloaded query to help optimisation.</param>
/// <returns>
/// An enumeration of doctor that are doubloons with the specified doctor
/// </returns>
public IEnumerable<LightDoctorDto> GetDoubloonsOf(string firstName, string lastName, TagDto specialisation)
{
return this.GetDoubloonsOf(firstName, lastName, specialisation, null);
}
public void TagOperation(TagViewModel tag)
{
_newTag = tag.Tag;
TagService.BeginTagOperation(Operation.Id, tag.Tag.Id,EndTagOperation,null);
}
/// <summary>
/// Sets the specified tag to the list of patients.
/// </summary>
/// <param name="tag">The tag to set.</param>
/// <param name="patients">The patients.</param>
public void SetTag(TagDto tag, IEnumerable<LightPatientDto> patients)
{
var eTag = GetTag(tag);
var ePatients = this.Load(patients);
foreach (var patient in ePatients)
{
patient.Tag = eTag;
this.Session.Update(patient);
}
}
/// <summary>
/// Updates the specified tag.
/// </summary>
/// <param name="tag">The tag.</param>
public void Update(TagDto tag)
{
new Updator(this.Session).Update(tag);
}
private void InitTestData()
{
_location = new LocationDto
{
Id = Guid.NewGuid(),
Cities = new List <CityDto>
{
new CityDto
{
Id = Guid.NewGuid(),
Name = "Minsk"
}
},
Country = "Belarus"
};
_vendor = new VendorDto
{
Id = Guid.NewGuid(),
Name = "Vendor",
Links = new List <LinkDto>
{
new LinkDto
{
Type = LinkType.Website,
Url = "v.com"
}
},
Addresses = new List <AddressDto>
{
new AddressDto
{
Id = 1,
CityId = _location.Cities[0].Id,
CountryId = _location.Id,
Street = "street"
}
},
Phones = new List <PhoneDto>
{
new PhoneDto
{
Id = 1,
Number = "+375441111111"
}
}
};
_category = new CategoryDto
{
Id = Guid.NewGuid(),
Name = "Category"
};
_tag = new TagDto
{
Id = Guid.NewGuid(),
Name = "Tag",
CategoryId = _category.Id
};
_discount = new Discount
{
Id = Guid.NewGuid(),
PhonesIds = new List <int>
{
_vendor.Phones.ElementAt(0).Id
},
CategoryId = _category.Id,
Conditions = "Conditions",
TagsIds = new List <Guid> {
_tag.Id
},
VendorId = _vendor.Id,
VendorName = _vendor.Name,
PromoCode = "new promo code",
StartDate = DateTime.UtcNow.Date,
EndDate = DateTime.UtcNow.Date
};
_vendorSearch = new VendorSearch
{
Id = _vendor.Id,
Categories = new List <string> {
_category.Name
},
Tags = new List <string> {
_tag.Name
},
Discounts = new List <string> {
_discount.Conditions
},
Vendor = _vendor.Name,
Cities = new List <string> {
_location.Cities[0].Name
},
Countries = new List <string> {
_location.Country
},
Streets = new List <string> {
_vendor.Addresses.ElementAt(0).Street
}
};
_vendor.Discounts = new List <DiscountShortDto>
{
Mapper.Map <DiscountShortDto>(_discount)
};
}
protected override void Insert()
{
this.component.Create(this.Tag);
this.Tag = new TagDto(TagCategory.Doctor);
}
private void AssertJourneySpecificDataOnStandardTag(TagDto tagDto)
{
AssertEqualAndNotNull(_mode2.Title, tagDto.NextMode);
AssertEqualAndNotNull(_responsible2.Code, tagDto.NextResponsibleCode);
AssertEqualAndNotNull(_responsible2.Description, tagDto.NextResponsibleDescription);
}
public async Task <int> InsertTag([FromBody] TagDto vm)
{
return(await _tagService.InsertTagAsync(vm));
}
private IEnumerable<LightPatientDto> SetDefaultTagAsync()
{
var defaultName = "Patient";
var defaultTag = this.Component.GetTag(defaultName);
if (defaultTag == null) { defaultTag = new TagDto(TagCategory.Patient) { Name = defaultName }; }
this.Component.SetTag(defaultTag, this.UntaggedPatients);
return this.Component.GetUntaggedPatients();
}
private IEnumerable<LightDoctorDto> GetDoubloonsOf(string firstName, string lastName, TagDto specialisation, IQueryable<Doctor> query)
{
if (query == null) { query = this.Session.Query<Doctor>(); }
var entities = (from doc in query
where doc.FirstName == firstName
&& doc.LastName == lastName
&& doc.Specialisation.Id == specialisation.Id
select doc).AsEnumerable();
return Mapper.Map<IEnumerable<Doctor>, IEnumerable<LightDoctorDto>>(entities);
}
public IList<LightPictureDto> GetLightPictures(LightPatientDto patient, TagDto tag)
{
var pictures = GetEntityPictures(patient, tag);
var result = Mapper.Map<IList<Picture>, IList<LightPictureDto>>(pictures);
return result;
}
/// <summary>
/// 取关
/// </summary>
/// <param name="groupName"></param>
/// <param name="count"></param>
public void UnfollowBatched(string groupName, int count)
{
_logger.LogInformation("【分组名】{group}", groupName);
//根据分组名称获取tag
TagDto tag = GetTag(groupName);
int? tagId = tag?.Tagid;
int total = tag?.Count ?? 0;
if (!tagId.HasValue)
{
_logger.LogWarning("分组名称不存在");
return;
}
if (total == 0)
{
_logger.LogWarning("分组下不存在up");
return;
}
if (count == -1)
{
count = total;
}
_logger.LogInformation("【分组下共有】{count}人", total);
_logger.LogInformation("【目标取关】{count}人" + Environment.NewLine, count);
//计算共几页
int totalPage = (int)Math.Ceiling(total / (double)20);
//从最后一页开始获取
var req = new GetSpecialFollowingsRequest(long.Parse(_cookie.UserId), tagId.Value)
{
Pn = totalPage
};
List <UpInfo> followings = _relationApi.GetFollowingsByTag(req)
.GetAwaiter().GetResult()
.Data;
followings.Reverse();
var targetList = new List <UpInfo>();
if (count <= followings.Count)
{
targetList = followings.Take(count).ToList();
}
else
{
int pn = totalPage;
while (targetList.Count < count)
{
targetList.AddRange(followings);
//获取前一页
pn -= 1;
if (pn <= 0)
{
break;
}
req.Pn = pn;
followings = _relationApi.GetFollowingsByTag(req)
.GetAwaiter().GetResult()
.Data;
followings.Reverse();
}
}
_logger.LogInformation("开始取关..." + Environment.NewLine);
int success = 0;
for (int i = 1; i <= targetList.Count && i <= count; i++)
{
UpInfo info = targetList[i - 1];
_logger.LogInformation("【序号】{num}", i);
_logger.LogInformation("【UP】{up}", info.Uname);
string modifyReferer = string.Format(RelationApiConstant.ModifyReferer, _cookie.UserId, tagId);
var modifyReq = new ModifyRelationRequest(info.Mid, _cookie.BiliJct);
var re = _relationApi.ModifyRelation(modifyReq, modifyReferer)
.GetAwaiter().GetResult();
if (re.Code == 0)
{
_logger.LogInformation("【取关结果】成功" + Environment.NewLine);
success++;
}
else
{
_logger.LogInformation("【取关结果】失败");
_logger.LogInformation("【原因】{msg}" + Environment.NewLine, re.Message);
}
}
_logger.LogInformation("【本次共取关】{count}人", success);
//计算剩余
tag = GetTag(groupName);
_logger.LogInformation("【分组下剩余】{count}人", tag?.Count ?? 0);
}
private Tag GetTag(TagDto tag)
{
var eTag = (from t in this.Session.Query<Tag>()
where t.Id == tag.Id
select t).FirstOrDefault();
if (eTag == null)
{
eTag = Mapper.Map<TagDto, Tag>(tag);
var id = this.Session.Save(eTag);
eTag = this.Session.Get<Tag>(id);
}
return eTag;
}
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
private void AssertJourneySpecificDataOnSiteTag(TagDto tagDto)
{
Assert.IsNull(tagDto.NextMode);
Assert.IsNull(tagDto.NextResponsibleCode);
Assert.IsNull(tagDto.NextResponsibleDescription);
}
public string Insert([FromBody] TagDto doc)
{
return(_tagsDbService.InsertTag(doc));
}
/// <summary>
/// Create the specified item into the database
/// </summary>
/// <param name="item">The item to add in the database</param>
/// <returns>
/// The id of the just created item
/// </returns>
public long Create(TagDto item)
{
return(new Creator(this.Session).Create(item));
}
public void Update([FromRoute] string docId, [FromBody] TagDto doc)
{
_tagsDbService.UpdateTag(new ObjectId(docId), doc);
}
public TagViewModel(TagDto tag)
{
Tag = tag;
IsNew = false;
}
public async Task CreateOrEditTag(TagDto input)
{
await _unitOfWork.Tags.CreateOrEditTag(input);
}
public async Task CreateTagAsync(TagDto tag)
{
await _bus.SendAsync(new StartTagCommand(tag.BlogId, tag.Url, tag.Title));
}
public async Task GetTagForEdit(TagDto input)
{
await _unitOfWork.Tags.GetTagForEdit(input);
}
public static void SetSpecialisation(DependencyObject target, TagDto value)
{
target.SetValue(SpecialisationProperty, value);
}
public List <TagDto> GetAllTag(TagDto input)
{
return(_unitOfWork.Tags.GetAllTag(input));
}
/// <summary>
/// Determines whether this instance can remove the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>
/// <c>true</c> if this instance can remove the specified item; otherwise, <c>false</c>.
/// </returns>
public bool CanRemove(TagDto item)
{
return new Remover(this.Session).CanRemove(item);
}
/// <summary>
/// Updates the specified tag.
/// </summary>
/// <param name="tag">The tag.</param>
public void Update(TagDto tag)
{
var entity = Mapper.Map <TagDto, Tag>(tag);
this.Session.Update(entity);
}
/// <summary>
/// Removes item with the specified id.
/// </summary>
/// <param name="item"></param>
public void Remove(TagDto item)
{
new Remover(this.Session).Remove(item);
}
private async Task CreateTagInPost(HttpClient httpClient, TagDto newTag)
{
var tagResult = await httpClient.PostAsJsonAsync(createTagUri, newTag);
Assert.AreEqual(HttpStatusCode.NoContent, tagResult.StatusCode, "POST API method failed (for tag)");
}
public static void SetStamp(DependencyObject target, TagDto value)
{
target.SetValue(StampProperty, value);
}
private async Task EnsurePostHasTagDeleted(HttpClient httpClient, int newPostId, HttpResponseMessage getResult, TagDto newTag)
{
var getResult2 = await httpClient.GetAsync(getPostUri(newPostId));
Assert.AreEqual(HttpStatusCode.OK, getResult.StatusCode, "GET API method failed (for post)");
var postLoaded2 = new JavaScriptSerializer().Deserialize <PostDetailsModel>(getResult2.Content.ReadAsStringAsync().Result);
Assert.IsFalse(postLoaded2.Tags.Contains(newTag.Tag));
}
private async Task DeleteTagFromPost(HttpClient httpClient, int newPostId, TagDto newTag)
{
var untagResult = await httpClient.DeleteAsync(createTagInPostUri(newPostId, newTag.Tag));
Assert.AreEqual(HttpStatusCode.NoContent, untagResult.StatusCode, "DELETE API method failed (for tag)");
}
private async Task <HttpResponseMessage> GetPostWithTag(HttpClient httpClient, int newPostId, TagDto newTag)
{
var getResult = await httpClient.GetAsync(getPostUri(newPostId));
Assert.AreEqual(HttpStatusCode.OK, getResult.StatusCode, "GET API method failed (for post)");
var postLoaded = new JavaScriptSerializer().Deserialize <PostDetailsModel>(getResult.Content.ReadAsStringAsync().Result);
Assert.IsTrue(postLoaded.Tags.Contains(newTag.Tag));
return(getResult);
}
/// <summary>
/// Create the specified item into the database
/// </summary>
/// <param name="item">The item to add in the database</param>
/// <returns>
/// The id of the just created item
/// </returns>
public long Create(TagDto item)
{
return new Creator(this.Session).Create(item);
}
public TagViewModel()
{
Tag = new TagDto();
IsNew = true;
}
