private void Save_Click(object sender, RoutedEventArgs e)
{
var diagram = _storageService.GetByName(DrawingName.Text.Trim());
if (diagram != null)
{
if (MessageBox.Show($"已经存在名为：'{DrawingName.Text.Trim()}'的图形，确定覆盖现有图形？", "警告", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
{
diagram.Shapes = _shapes;
_storageService.Update(diagram);
DialogResult = true;
Close();
MessageBox.Show("更新完成！");
}
return;
}
diagram = new Diagram
{
Id = Guid.NewGuid(),
Name = DrawingName.Text.Trim(),
Shapes = _shapes
};
_storageService.Add(diagram);
DialogResult = true;
Close();
MessageBox.Show("保存完成！");
}
/// <summary>
/// Stores a connection response
/// </summary>
/// <returns>The connection response.</returns>
/// <param name="message">Message.</param>
/// <param name="context">Context.</param>
protected virtual async Task <Msg> StoreConnectionResponse(Msg message, IdentityContext context)
{
await Task.Yield();
storageService.Add(message);
return(null);
}
public ActionResult <Guid> Create(Item item)
{
var id = _storage.Add(item);
if (!id.HasValue)
{
return(Conflict());
}
return(CreatedAtAction(nameof(GetById), new { id }, null));
}
public LocalImdbService(ILogger <LocalImdbService> logger, IStorageService <Actor> storageService, WebScraper scraper)
{
this.scraper = scraper;
this.logger = logger;
this.storageService = storageService;
scraper.Set(ListActors());
scraper
.Subscribe(actor => storageService.Add(
Enumerable.Repeat <Actor>(actor, 1)));
}
public async Task <IActionResult> Add([FromBody] AddStorageDto addStorageDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var itemModel = dtoMapper.Map <AddStorageDto, Storage>(addStorageDto);
await storageService.Add(itemModel);
return(Ok("Product added."));
}
public async Task <string> Events(SlackMessage message)
{
if (message.Type == EventType.UrlVerification)
{
return(message.Challenge);
}
if (message.Type == EventType.EventCallback && message.Event.Type == MessageType.Message)
{
await _storageService.Add(_mapper.Map <StoredMessage>(message));
}
return(string.Empty);
}
public IAjaxResult AddStorage(Storage storage)
{
switch (_storageService.Add(storage))
{
case 0: return(Success("添加成功"));
case 1: return(Error("添加失败"));
case 2: return(Error("改名字已存在，请更换名字后重新添加"));
case 3: return(Error("请完整填写信息"));
default: return(Error("请求失败"));
}
}
public ActionResult UploadFiles(List <HttpPostedFileBase> postedFiles, string container, string path)
{
foreach (HttpPostedFileBase postedFile in postedFiles)
{
if (postedFile != null)
{
string fileName = Path.GetFileName(postedFile.FileName);
byte[] bytes = new byte[postedFile.ContentLength];
postedFile.InputStream.Read(bytes, 0, bytes.Length);
var ms = new MemoryStream(bytes);
_storageService.Add(container, HttpUtility.HtmlDecode(path) + fileName, ms, postedFile.ContentLength);
GC.Collect();
}
}
return(RedirectToAction("Index", new { container, path }));
}
private void CreateCommandsOnNode(ConfigurationNode node, PropertyInfo[] properties)
{
IStorageService storageService = ServiceHelper.GetCurrentStorageService(ServiceProvider);
foreach (PropertyInfo property in properties)
{
StorageCreationAttribute[] storageCreationAttributes = (StorageCreationAttribute[])property.GetCustomAttributes(typeof(StorageCreationAttribute), true);
foreach (StorageCreationAttribute storageCreationAttribute in storageCreationAttributes)
{
StorageCreationCommand cmd = storageCreationAttribute.CreateCommand(node, property, ServiceProvider);
if (!storageService.Contains(cmd.Name))
{
storageService.Add(cmd);
}
}
}
}
public async Task <string> Send([FromBody] Message message)
{
var isSendToAllRecipienrs = _notificationService.TryNotifyRecepients(message.RecipientIds, message.Body);
// In real app it is better to use mapper instead of this part
var dbMessage = new DbMessage
{
IsSent = isSendToAllRecipienrs,
Body = message.Body,
MessageRecipients = message.RecipientIds.Select(x => new DbMessageRecipient {
RecipientId = x
}).ToList(),
Subject = message.Subject
};
await _storageService.Add(dbMessage);
return(dbMessage.Id);
}
public void acknowledge_RESULT_OK()
{
// arrange
var key = "test_key";
_storageService.Add(key, "whatever object", null);
Guid faceId = Guid.NewGuid();
Guid personId = Guid.NewGuid();
var faceServiceMock = new Mock <IFaceServiceClient>();
var obj = new FaceController(Services.GetRequiredService <IHostingEnvironment>(), faceServiceMock.Object, _storageService);
// act
var result = obj.Acknowledge(key);
// assert
var storageObject = _storageService.Get(key);
Assert.Null(storageObject);
}
public int Add(User user, IUserValidator userValidator = null)
{
if (userValidator == null)
{
userValidator = new BaseValidation();
}
var listOfUsers = _userStorageService.GetAllUsers().ToList();
var validationResult = userValidator.Validate(listOfUsers, user);
if (validationResult.IsInvalidUser)
{
throw new UserCreateException(validationResult.ErrorMessage);
}
user.Id = _idGeneratorFunction(listOfUsers);
_userStorageService.Add(user);
return(user.Id);
}
public async Task <string> AddPhoto([FromForm] IFormFile file)
{
if (file == null || file.Length == 0)
{
throw new ArgumentNullException();
}
var imageName = $"{Guid.NewGuid().ToString()}.{file.ContentType.GetExtension()}";
var fileAsBytes = await file.GetBytesAsync();
var storageContainerName = _storageConfig.Value.PublicContainerName;
var fileName = await _storageService.Add(fileAsBytes, storageContainerName, imageName, file.ContentType);
var photoEntity = new Photo(fileName);
await _context.AddAsync(photoEntity);
await _context.SaveChangesAsync();
var fullPath = $"{_storageConfig.Value.Url}/{storageContainerName}/{fileName}";
return(fullPath);
}
public async Task <ActionResult <ReviewModel> > AddReview(ReviewModel model)
{
var result = await storageService.Add(model.ToEntity());
return(result);
}
public IActionResult Post([FromBody] Task task)
{
var createdTask = _storageService.Add(task);
return(CreatedAtAction("Task", createdTask));
}
public async Task StartSync()
{
var actors = await this.scraper.Run(ListActors());
storageService.Add(actors);
}
public async Task <IActionResult> Upload(IFormFile file)
{
// saving file locally
var fileName = GetFileName(file);
var fileExtension = (fileName.Split('.')).Last();
var key = ("file_" + DateTime.UtcNow.ToString().ToLowerInvariant()).Replace(":", "_").Replace("/", "_").Replace(" ", "") + "." + fileExtension;
string filePath = Path.Combine(Directory.GetCurrentDirectory(), "images", key);
string dirPath = Path.Combine(Directory.GetCurrentDirectory(), "images");
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
var inputStream = file.OpenReadStream();
await inputStream.CopyToAsync(fileStream);
}
var response = new ResponseModel();
using (Stream s = new FileStream(filePath, FileMode.Open))
{
// DETECT faces in photo
var faces = await _faceService.DetectAsync(s, true, false, new[] { FaceAttributeType.Age, FaceAttributeType.Gender, FaceAttributeType.Glasses });
// if no face detected, return with NotFound status
if (!faces.Any())
{
return(NotFound());
}
// sort faces DETECTED by face id
var faceIds = faces.OrderBy(f => f.FaceId).Select(face => face.FaceId).ToArray();
// IDENTIFY faces DETECED
var identifyResults = await _faceService.IdentifyAsync(_personGroupId, faceIds);
foreach (var face in faces)
{
var faceModel = new FaceModel(face);
// for each face DETECTED in photo, if any is IDENTIFIED
if (identifyResults.Any(f => f.FaceId == face.FaceId))
{
// get the IDENTIFIED face
var identifyResult = identifyResults.FirstOrDefault(f => f.FaceId == face.FaceId);
// if the IDENTIFIED face has any possible CANDIDATES
for (int i = 0; i < identifyResult.Candidates.Length; i++)
{
// get the CANDIDATE's name
var candidateId = identifyResult.Candidates[i].PersonId;
var person = await _faceService.GetPersonAsync(_personGroupId, candidateId);
faceModel.Candidates.Add(new CandidateModel {
PersonId = candidateId.ToString(), Confidence = identifyResult.Candidates[i].Confidence, PersonName = person.Name
});
}
}
response.Faces.Add(faceModel);
}
}
response.Key = key;
_storageService.Add(key, response, file);
return(Ok(response));
}
