public void CreateInspectionYardTest()
{
Inspection inspection = new Inspection();
List <Damage> damages = new List <Damage>();
Damage damage = new Damage();
damage.Description = "Puerta rota";
List <Base64Image> images = new List <Base64Image>();
Base64Image image = new Base64Image();
image.Base64EncodedImage = "test";
images.Add(image);
damage.Images = images;
damages.Add(damage);
inspection.Damages = damages;
DateTime date = new DateTime();
inspection.Date = date;
Location location = new Location(Yards.FIRST_YARD);
inspection.IdLocation = location;
inspection.IdUser.UserName = "******";
Assert.AreEqual("Puerta rota", inspection.Damages.ElementAt(0).Description);
Assert.AreEqual("test", inspection.Damages.ElementAt(0).Images.ElementAt(0).Base64EncodedImage);
Assert.AreEqual(date, inspection.Date);
Assert.AreEqual(location, inspection.IdLocation);
Assert.AreEqual("pepito123", inspection.IdUser.UserName);
}
/// <summary>
/// get base64 strings of all of the images for the specified document
/// </summary>
/// <param name="sessionToken">the token received from logging into the integration server</param>
/// <param name="documentId">the document's unique identifier within the imaging system</param>
/// <returns>all pages of the document in a base64 string list</returns>
/// <remarks>
/// jwames - 3/31/2015 - original code
/// </remarks>
public List <Base64Image> GetImages(string sessionToken, string documentId)
{
if (sessionToken.Length == 0)
{
throw new ArgumentException("SessionToken cannot be blank. Reauthentication might be necessary.");
}
if (documentId.Length == 0)
{
throw new ArgumentException("DocumentId cannot be blank.");
}
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Add(Constants.IMAGING_HEADER_SESSIONTOKEN, sessionToken);
client.DefaultRequestHeaders.Add("Accept", "application/json");
try
{
string endPoint = string.Format("{0}{1}/{2}/page", Configuration.ImagingServerUrl, API_ENDPOINT_DOCUMENT, documentId);
System.Net.Http.HttpResponseMessage response = client.GetAsync(endPoint).Result;
if (response.StatusCode.Equals(System.Net.HttpStatusCode.OK) || response.StatusCode.Equals(System.Net.HttpStatusCode.NoContent))
{
string rawJson = response.Content.ReadAsStringAsync().Result;
ImageNowPageReturnModel jsonResponse = Newtonsoft.Json.JsonConvert.DeserializeObject <ImageNowPageReturnModel>(rawJson);
List <Tuple <int, Base64Image> > processedImages = new List <Tuple <int, Base64Image> >();
Parallel.ForEach(jsonResponse.pages, page => {
Base64Image myImage = new Base64Image();
if (page.extension.Equals("pdf", StringComparison.InvariantCultureIgnoreCase))
{
myImage.MimeType = Constants.MIMETYPE_PDF;
myImage.ImageString = GetPdfAsBase64String(sessionToken, documentId, page.id);
}
else
{
myImage.MimeType = Constants.MIMETYPE_JPG;
myImage.ImageString = GetImageString(sessionToken, documentId, page.id);
}
processedImages.Add(new Tuple <int, Base64Image>(page.pageNumber, myImage));
});
return(processedImages.OrderBy(p => p.Item1).Select(t => t.Item2).ToList());
}
else
{
throw new ApplicationException("Document not found");
}
}
catch (Exception ex)
{
_log.WriteErrorLog("Error connecting to the Imaging Server", ex);
throw;
}
}
}
public Task <VerifyFaceResponse> VerifyFaceAsync(Base64Image base64Image, string subjectId, string galleryName)
{
if (base64Image is null)
{
throw new ArgumentException("base64 image is required", nameof(base64Image));
}
if (string.IsNullOrWhiteSpace(subjectId))
{
throw new ArgumentException("subject id is required", nameof(subjectId));
}
if (string.IsNullOrWhiteSpace(galleryName))
{
throw new ArgumentException("gallery name", nameof(galleryName));
}
var payload = new
{
image = base64Image.Value,
subject_id = subjectId,
gallery_name = galleryName
};
return(SendPostRequest <VerifyFaceResponse>("verify", payload));
}
public void PersistBase64ImageTest()
{
Base64ImageDAO imageDAO = new Base64ImageDAOImp();
Base64Image image = new Base64Image();
image.Base64EncodedImage = Convert.ToBase64String(File.ReadAllBytes(@"..\..\Damage\attention.png"));
Base64Image existImage = imageDAO.FindImageByBase64Encode(image.Base64EncodedImage);
if (existImage == null)
{
imageDAO.AddImage(image);
}
else
{
image.Id = existImage.Id;
}
Base64Image resultImage = imageDAO.FindImageByBase64Encode(image.Base64EncodedImage);
Assert.AreEqual(image.Id, resultImage.Id);
Assert.AreEqual(image.Base64EncodedImage, resultImage.Base64EncodedImage);
}
public IList <Base64Image> GetBase64Images(string[] files)
{
if (files == null || files.Length == 0)
{
return(new List <Base64Image>());
}
var images = new List <Base64Image>();
foreach (var file in files)
{
if (IsImage(file))
{
using (var image = Image.FromFile(file))
{
var base64 = GetBase64(image);
if (!string.IsNullOrWhiteSpace(base64))
{
var base64Image = new Base64Image(file, image.Width, image.Height, base64);
images.Add(base64Image);
}
};
}
}
return(images.ToList());
}
private void btnFileDilaog_Click(object sender, EventArgs e)
{
OpenFileDialog fdlg = new OpenFileDialog();
fdlg.Title = "Open File Dialog";
fdlg.InitialDirectory = @"D:\Org Level Activities\Rfps\Bajaj Allianz";
if (rbImage.Checked)
{
fdlg.Filter = "Image files (*.jpg, *.jpeg) | *.jpg; *.jpeg;";
}
else if (rbDocument.Checked)
{
fdlg.Filter = "Document files (*.xlsx) | *.xlsx;";
}
fdlg.FilterIndex = 2;
fdlg.RestoreDirectory = true;
if (fdlg.ShowDialog() == DialogResult.OK)
{
txtFilePath.Text = Path.GetFileName(fdlg.FileName);
if (rbImage.Checked)
{
var base64Img = new Base64Image
{
FileContents = File.ReadAllBytes(fdlg.FileName),
ContentType = "image/jpg"
};
base64EncodedImg = base64Img.ToString();
}
else if (rbDocument.Checked)
{
Byte[] bytes = File.ReadAllBytes(fdlg.FileName);
base64ExcelDocument = string.Format("data:attachment/xlsx;base64,{0}", Convert.ToBase64String(bytes));
}
}
}
private static ObjectResult CreateResponse(Base64Image outputImg)
{
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Converters.Add(new Base64ImageJsonConverter());
return(new OkObjectResult(JsonConvert.SerializeObject(new ImageResponse(outputImg), settings)));
}
public string SaveAndReturnKey(ImageType type, Base64Image base64Image, Guid userId, bool cropCenter)
{
var stream = base64Image.GetStream();
var key = SaveImageAndReturnKey(type, base64Image.FileName, stream, userId, null, cropCenter);
stream.Dispose();
return key;
}
public string SaveAndReturnKey(ImageType type, Base64Image base64Image, Guid userId, bool cropCenter)
{
var stream = base64Image.GetStream();
var key = SaveImageAndReturnKey(type, base64Image.FileName, stream, userId, null, cropCenter);
stream.Dispose();
return(key);
}
/// <summary>
/// Converts <see cref="Mailing.Base64Image"/> to <see cref="CES.image"/>.
/// </summary>
/// <param name="base64Image">Instance of <see cref="Mailing.Base64Image"/>.</param>
/// <returns><see cref="CES.image"/>.</returns>
public static image ToCESImage(this Base64Image base64Image)
{
return(new image()
{
content = base64Image.Content,
type = base64Image.MimeType,
name = base64Image.Name
});
}
public void ToString_ReturnsValue()
{
var base64String = "base64";
var base64Image = new Base64Image(base64String);
var result = base64Image.ToString();
result.Should().Be(base64String);
}
public void Conversion_ToString_ReturnsBase64ImageValue()
{
var base64String = "base64";
var base64Image = new Base64Image(base64String);
string result = base64Image;
result.Should().Be(base64String);
}
public Guid AddImage(Base64Image image)
{
using (VehicleTrackingDbContext context = new VehicleTrackingDbContext())
{
context.Images.Add(image);
context.SaveChanges();
}
return(image.Id);
}
/// <summary>
/// Constructor for a feature extractor using Google Cloud Platform by performing a raw HTTP-POST directly to
/// the API endpoint, optimized for analysing a single image.
/// </summary>
/// <param name="imageStream"></param>
/// <param name="apiKey"></param>
public GcpApiFeatureExtractor(Stream imageStream, string apiKey)
{
SetRotation(SKCodec.Create(imageStream).EncodedOrigin);
var size = Image.FromStream(imageStream).Size;
Width = size.Width;
Height = size.Height;
_apiKey = apiKey;
_image = new Base64Image(imageStream);
}
public Base64Image FindImageByBase64Encode(string code)
{
Base64Image image = null;
using (VehicleTrackingDbContext context = new VehicleTrackingDbContext())
{
image = context.Images
.Where(i => i.Base64EncodedImage == code)
.ToList().FirstOrDefault();
}
return(image);
}
public void MapBase64ImageToBase64ImageDTOTest()
{
Base64ImageDAO imageDAO = new Base64ImageDAOImp();
Base64ImageMapper mapper = new Base64ImageMapper(imageDAO);
Base64Image image = new Base64Image();
image.Base64EncodedImage = "1234";
Base64ImageDTO imageDTO = mapper.ToDTO(image);
Assert.AreEqual(image.Base64EncodedImage, imageDTO.Base64EncodedImage);
}
/// <summary>
/// Получаем изображение по id слоя
/// </summary>
/// <param name="zIndex">id слоя</param>
/// <returns>Картинка, или null, если такого слоя нету в списке</returns>
public Base64Image getImageFromLayer(int zIndex)
{
Base64Image ex = null;
//Если такой слой найден - возвращаем его картинку
if (images.ContainsKey(zIndex))
{
ex = images[zIndex].image;
}
//В проитивном случае - возвращаем null
return(ex);
}
public void MapBase64ImageDTOToBase64ImageTest()
{
Base64ImageDAO imageDAO = new Base64ImageDAOImp();
Base64ImageMapper mapper = new Base64ImageMapper(imageDAO);
Base64ImageDTO image = new Base64ImageDTO();
image.Base64EncodedImage = "1234";
Base64Image imageEntity = mapper.ToEntity(image);
Assert.AreEqual(image.Base64EncodedImage, imageEntity.Base64EncodedImage);
Assert.IsNotNull(imageEntity.Id);
}
public ClientResponse InsertGaleria(Tbl_galeria_anuncio objeto)
{
ClientResponse clientResponse = new ClientResponse();
try
{
Tbl_parameter_det entidad_rutas_fisica_fichas = new Tbl_parameter_det()
{
skey_det = "SKEY_RUTASFISICAS_FICHAS", paramter_cab = new Tbl_parameter_cab()
{
skey_cab = "SKEY_RUTAS_FICHAS"
}
};
ClientResponse respons_rutas_fisica_fichas = new ParameterLogic().GetParameter_skey_x_det_Id(entidad_rutas_fisica_fichas);
Tbl_parameter_det rutas_fisica_image = Newtonsoft.Json.JsonConvert.DeserializeObject <Tbl_parameter_det>(respons_rutas_fisica_fichas.DataJson);
string tempPath = rutas_fisica_image.tx_descripcion + objeto.id_anuncio;
byte[] imageBytes = System.Convert.FromBase64String(objeto.tx_ruta_file);
if (!Directory.Exists(tempPath))
{
Directory.CreateDirectory(tempPath);
}
string file_ruta = tempPath + @"/" + objeto.tx_filename + "." + objeto.tx_extension_archivo;
File.WriteAllBytes(file_ruta, imageBytes);
string _b64 = Convert.ToBase64String(File.ReadAllBytes(file_ruta));
var base64Img = new Base64Image
{
FileContents = File.ReadAllBytes(file_ruta),
ContentType = "image/png"
};
string base64EncodedImg = base64Img.ToString();
Tbl_galeria_anuncio entidad = new Tbl_galeria_anuncio()
{
Base64ContentFicha = base64EncodedImg,
Base64ContentFichaCort = base64EncodedImg,
id_anuncio = objeto.id_anuncio,
tx_filename = objeto.tx_filename + "." + objeto.tx_extension_archivo,
size_file = 0
};
clientResponse = new GaleriaLogic().Insert_GaleriaObject(entidad);
}
catch (Exception ex)
{
clientResponse = Utilidades.ObtenerMensajeErrorWeb(ex);
}
return(clientResponse);
}
public void CreateDamageTest()
{
Vehicle vehicle = new Vehicle();
Damage damage = new Damage();
damage.Description = "Daño en la puerta derecha";
Base64Image base64Image = new Base64Image();
base64Image.Base64EncodedImage = Convert.ToBase64String(File.ReadAllBytes(@"..\..\Damage\attention.png"));
damage.Images = new List <Base64Image>();
damage.Images.Add(base64Image);
Assert.AreEqual(damage.Description, "Daño en la puerta derecha");
Assert.IsTrue(damage.Images.Contains(base64Image));
}
public Task <DetectFacesResponse> DetectFacesAsync(Base64Image base64Image, string selector = "ROLL")
{
if (base64Image is null)
{
throw new ArgumentException("base64 image is required", nameof(base64Image));
}
var payload = new
{
image = base64Image.Value,
selector = selector
};
return(SendPostRequest <DetectFacesResponse>("detect", payload));
}
public async Task <IActionResult> UpdateImageAsync(string organizationId, Base64Image dataObject)
{
User user = await Session.GetCurrentUser();
if (user == null || string.IsNullOrEmpty(dataObject.Image))
{
return(Unauthorized());
}
byte[] bytes = Convert.FromBase64String(dataObject.Image);
System.IO.MemoryStream ms = new System.IO.MemoryStream(bytes);
return(Ok(await OrganizationRepository.UpdateImageAsync(user, organizationId, ms)));
}
public Damage ToEntity(DamageDTO damageDTO)
{
Damage damage = new Damage();
damage.Description = damageDTO.Description;
damage.Images = new List <Base64Image>();
foreach (var imageDTO in damageDTO.Images)
{
Base64Image image = new Base64Image();
image.Base64EncodedImage = imageDTO.Base64EncodedImage;
damage.Images.Add(image);
}
return(damage);
}
public static void Main(string[] args)
{
//for (int i = 0; i < 10; i++)
//{
// Thread.Sleep(1000);
// Console.WriteLine(VerificationUtils.GetVefication());
//}
////
string path = @"D://temp//Tim.jpg";
string base64 = Base64Image.GetBase64FromImage(path);
Console.ReadKey(false);
}
public static async Task UploadImage(IImageRepository _imageRepository, Base64Image image)
{
byte[] data = System.Convert.FromBase64String(image.Base64Picture.Split(',')[1]);
var imageInfo = new ImageInfo
{
Date = image.Date,
Id = image.Id,
Name = image.Name
};
var imageStorage = new ImageStorage
{
ImageInfoId = image.Id,
Picture = data,
};
await _imageRepository.UploadImage(imageInfo, imageStorage);
}
public Inspection ToEntity(InspectionDTO inspectionDTO)
{
Location location = GetLocation(inspectionDTO.Location);
Inspection inspection = new Inspection();
inspection.Date = inspectionDTO.Date;
inspection.Id = inspectionDTO.Id;
inspection.IdLocation = location;
User user = new User();
user.UserName = inspectionDTO.CreatorUserName;
Vehicle vehicle = new Vehicle();
vehicle.Vin = inspectionDTO.IdVehicle;
inspection.IdUser = user;
inspection.IdVehicle = vehicle;
if (inspectionDTO.Damages != null)
{
List <Damage> damages = new List <Damage>();
foreach (DamageDTO damageDTO in inspectionDTO.Damages)
{
Damage damage = new Damage();
damage.Description = damageDTO.Description;
damage.Images = new List <Base64Image>();
foreach (Base64ImageDTO imageDTO in damageDTO.Images)
{
Base64Image image = new Base64Image();
image.Base64EncodedImage = imageDTO.Base64EncodedImage;
damage.Images.Add(image);
}
damages.Add(damage);
}
inspection.Damages = damages;
}
return(inspection);
}
public Task <RecognizeFaceResponse> RecognizeFaceAsync(Base64Image base64Image, string galleryName)
{
if (base64Image is null)
{
throw new ArgumentNullException(nameof(base64Image));
}
if (string.IsNullOrWhiteSpace(galleryName))
{
throw new ArgumentException("gallery name is required", nameof(galleryName));
}
var payload = new
{
image = base64Image.Value,
gallery_name = galleryName
};
return(SendPostRequest <RecognizeFaceResponse>("recognize", payload));
}
/// <summary>
/// Добавляем новый слой
/// </summary>
/// <param name="image">Сама картинка</param>
/// <param name="zIndex">Индекс в порядке слоёв</param>
/// <param name="layerName">Название слоя</param>
public void addImageLayer(Base64Image image, int zIndex, string layerName = "")
{
//Инициализируем новый слой
ImageLayer layer = new ImageLayer {
name = layerName,
image = image,
zIndex = zIndex
};
//Если такой слой уже есть, мы его заменяем.
if (images.ContainsKey(zIndex))
{
images[zIndex] = layer;
}
//В противном случае - просто добавляем новый
else
{
images.Add(zIndex, layer);
}
}
public void MapDamageToDamageDTOTest()
{
VehicleDTO vehicle = this.CreateVehicle();
DamageMapper mapper = new DamageMapper();
Base64Image base64Image = new Base64Image();
base64Image.Base64EncodedImage = Convert.ToBase64String(File.ReadAllBytes(@"..\..\Damage\attention.png"));
VehicleMapper vehicleMapper = new VehicleMapper();
Damage damage = new Damage();
damage.Description = "Daño en la puerta derecha";
damage.Images = new List <Base64Image>();
damage.Images.Add(base64Image);
DamageDTO damageDTO = mapper.ToDTO(damage);
Assert.AreEqual(damage.Description, damageDTO.Description);
foreach (Base64Image image in damage.Images)
{
Assert.IsNotNull(damageDTO.Images.Find(i => i.Base64EncodedImage == image.Base64EncodedImage));
}
}
public ApiResult UpdateAvatar(string id, [FromBody] Base64Image avatar)
{
Argument.ThrowIfNullOrEmpty(id, "会员Id");
Argument.ThrowIfNullOrEmpty(avatar.Data, "头像图片数据");
Argument.ThrowIfNullOrEmpty(avatar.FileName, "头像图片文件名");
if (string.IsNullOrWhiteSpace(Path.GetExtension(avatar.FileName)))
{
throw new WebApiInnerException("0003", "文件名称没有包含扩展名");
}
if (!AuthorizedUser.Id.Equals(id, StringComparison.OrdinalIgnoreCase))
{
throw new WebApiInnerException("0001", "只允许修改自己的头像");
}
var result = new ApiResult();
StorageFile storageFile;
if (_fileService.SaveFile(avatar.Data, avatar.FileName, false, out storageFile, 128, 128, 64, 64, ThumbnailType.TakeCenter))
{
_storageFileService.DisassociateFile(AuthorizedUser.Id.ToGuid(), MemberBaseModule.Key, "Avatar");
if (_storageFileService.AssociateFile(AuthorizedUser.Id.ToGuid(), MemberBaseModule.Key, MemberBaseModule.DisplayName, storageFile.Id, "Avatar"))
{
//更新缓存
_signals.Trigger(_userContainer.UserChangedSignalName);
_signals.Trigger($"member_{AuthorizedUser.Id}_changed");
result.SetData(storageFile.Simplified());
}
else
{
throw new WebApiInnerException("0002", "头像上传失败");
}
}
else
{
throw new WebApiInnerException("0002", "头像上传失败");
}
return(result);
}
private List <Damage> GetDamages(VehicleTrackingDbContext context, List <DamageDTO> damages)
{
List <Damage> resultDamages = null;
if (damages != null)
{
resultDamages = new List <Damage>();
foreach (var damage in damages)
{
Damage newDamage = new Damage();
newDamage.Description = damage.Description;
newDamage.Images = new List <Base64Image>();
foreach (Base64ImageDTO image in damage.Images)
{
Base64Image newImage = new Base64Image();
newImage.Base64EncodedImage = image.Base64EncodedImage;
newDamage.Images.Add(newImage);
}
resultDamages.Add(newDamage);
}
}
return(resultDamages);
}
public StandardJsonResult<string> Upload(ImageType type, Base64Image base64Image, bool cropCenter = false)
{
var result = new StandardJsonResult<string>();
result.Try(() =>
{
var service = Ioc.Get<IImageService>();
if (base64Image == null)
{
if (Request.Files.Count == 0 || Request.Files[0] == null)
{
throw new KnownException("找不到文件");
}
var file = Request.Files[0];
result.Value = service.SaveAndReturnKey(type, file, GetUserId(), cropCenter);
}
else
{
result.Value = service.SaveAndReturnKey(type, base64Image, GetUserId(), cropCenter);
}
});
result.ContentType = "text/plain";
return result;
}
