public static IEnumerable<DataReferenceLabelPair<IImageFile>> GenerateSelectorOptions(DataReference<IMediaFileFolder> folderReference)
{
IMediaFileFolder folder = null;
if (folderReference.IsSet)
{
try
{
folder = folderReference.Data;
}
catch (Exception)
{
string reference = folderReference.Serialize() ?? string.Empty;
LoggingService.LogError(LogTitle, "Failed to get media folder by referece: '{0}'".FormatWith(reference));
}
}
if (folder != null)
{
int pathLength = folder.Path.Length;
return
from mediaFile in DataFacade.GetData<IImageFile>()
where mediaFile.StoreId == folder.StoreId && mediaFile.FolderPath.StartsWith(folder.Path)
orderby mediaFile.StoreId, mediaFile.FolderPath, mediaFile.FileName
select new DataReferenceLabelPair<IImageFile>(mediaFile, mediaFile.FolderPath.Substring(pathLength) + "/" + mediaFile.FileName);
}
// Returning all of the images
return
from mediaFile in DataFacade.GetData<IImageFile>()
orderby mediaFile.StoreId, mediaFile.FolderPath, mediaFile.FileName
select new DataReferenceLabelPair<IImageFile>(mediaFile, mediaFile.StoreId + ":" + mediaFile.FolderPath + "/" + mediaFile.FileName);
}
public static XElement GetDocument(DataReference<IMediaFile> mediaFile, IDataReference apiKey)
{
var media = mediaFile.Data;
using (new IssuuApi(apiKey.Data))
{
lock (_lock)
{
var document = IssuuPlayerFacade.GetDocument(media);
if (document == null)
{
document = IssuuPlayerFacade.UploadDocument(media);
}
else
{
var publishDateAttribute = document.AttributeValue("publishDate");
DateTime publishDate = DateTime.Now;
DateTime.TryParse(publishDateAttribute, out publishDate);
if (publishDate < media.LastWriteTime)
{
IssuuPlayerFacade.DeleteDocument(media);
document = IssuuPlayerFacade.UploadDocument(media);
}
}
return document;
}
}
}
public static DataReference <TData> CreateDataReference <TData>(IQueryableEntity entity)
where TData : Data.IData
{
var dataReference = new DataReference <TData>();
((IDataReference)dataReference).Provider = entity;
return(dataReference);
}
public void ThenDerefernceMustResolveTheObject()
{
DataReference dataReference = new DataReference(Context, "testList");
var deref = dataReference.Dereference();
Assert.AreSame(deref, Context["testList"], "The context object was not resolved");
}
static bool IsPartialObjectSkipped(DataReference dataRef, dynamic obj)
{
if (dataRef.Type == "item" && obj.t == 59)
{
return(true); // Crystals are embedded.
}
return(false);
}
public void RoundtripSample1()
{
StringWriter sw = new StringWriter();
// Encryption
{
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.LoadXml("<root> <child>sample</child> </root>");
XmlElement body = doc.DocumentElement;
RijndaelManaged aes = new RijndaelManaged();
aes.Mode = CipherMode.CBC;
aes.KeySize = 256;
aes.IV = Convert.FromBase64String("pBUM5P03rZ6AE4ZK5EyBrw==");
aes.Key = Convert.FromBase64String("o/ilseZu+keLBBWGGPlUHweqxIPc4gzZEFWr2nBt640=");
aes.Padding = PaddingMode.Zeros;
EncryptedXml exml = new EncryptedXml();
byte [] encrypted = exml.EncryptData(body, aes, false);
EncryptedData edata = new EncryptedData();
edata.Type = EncryptedXml.XmlEncElementUrl;
edata.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
EncryptedKey ekey = new EncryptedKey();
// omit key encryption, here for testing
byte [] encKeyBytes = aes.Key;
ekey.CipherData = new CipherData(encKeyBytes);
ekey.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
DataReference dr = new DataReference();
dr.Uri = "_0";
ekey.AddReference(dr);
edata.KeyInfo.AddClause(new KeyInfoEncryptedKey(ekey));
edata.KeyInfo = new KeyInfo();
ekey.KeyInfo.AddClause(new RSAKeyValue(RSA.Create()));
edata.CipherData.CipherValue = encrypted;
EncryptedXml.ReplaceElement(doc.DocumentElement, edata, false);
doc.Save(new XmlTextWriter(sw));
}
// Decryption
{
RijndaelManaged aes = new RijndaelManaged();
aes.Mode = CipherMode.CBC;
aes.KeySize = 256;
aes.Key = Convert.FromBase64String(
"o/ilseZu+keLBBWGGPlUHweqxIPc4gzZEFWr2nBt640=");
aes.Padding = PaddingMode.Zeros;
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.LoadXml(sw.ToString());
EncryptedXml encxml = new EncryptedXml(doc);
EncryptedData edata = new EncryptedData();
edata.LoadXml(doc.DocumentElement);
encxml.ReplaceData(doc.DocumentElement, encxml.DecryptData(edata, aes));
}
}
private DataReference CreateDataReference(JToken item)
{
string refersTo = (string)item["refersTo"];
DataReference result = new DataReference(DataReference.CurrentContext(), refersTo);
result.DebugInfo = GetDebugInfo(item);
return(result);
}
private void Awake()
{
var gm = GameManager.Instance;
score = gm.Score;
coins = gm.Coins;
time = gm.GameTime;
uiInputModule.cancel.action.performed += ctx => SceneManager.LoadScene(0, LoadSceneMode.Single);
}
public DataReferenceViewModel(
[NotNull] DataReference dataReference,
[NotNull] IDataApiClient dataApiClient)
{
Model = dataReference ?? throw new ArgumentNullException(nameof(dataReference));
this.dataApiClient = dataApiClient ?? throw new ArgumentNullException(nameof(dataApiClient));
DownloadCommand = new AsyncRelayCommand(Download);
}
public CsvFileViewModel(
DataReference csvDataReference,
Table <string> data,
IObjectDatabase <ShortId> shortIdDatabase,
IDataApiClient dataApiClient)
{
Data = CreateDataGridColumns(data);
ShortIdEditViewModel = new ShortIdEditViewModel(csvDataReference, shortIdDatabase, dataApiClient);
}
/// <summary>
/// Initialise
/// </summary>
/// <param name="refA"></param>
/// <param name="refB"></param>
public CrossJoin(DataReference refA, DataReference refB)
{
var a = refA.Dereference() as IList <object>;
var b = refB.Dereference() as IList <object>;
_list = a.Join(b, p => 1, p => 1, (l, r) => new List <object> {
l, r
}).Cast <object>().ToList();
}
public object GetValue(DataReference parent)
{
if (parent == null)
{
parent = new DataReference(root());
}
return(parent.Value == null ? null : accessor(parent.Value));
}
public void RoundtripSample1()
{
using (StringWriter sw = new StringWriter())
{
// Encryption
{
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.LoadXml("<root> <child>sample</child> </root>");
XmlElement body = doc.DocumentElement;
var aes = CipherUtilities.GetCipher("AES/CBC/ZEROBYTEPADDING");
var ivdata = Convert.FromBase64String("pBUM5P03rZ6AE4ZK5EyBrw==");
var keydata = Convert.FromBase64String("o/ilseZu+keLBBWGGPlUHweqxIPc4gzZEFWr2nBt640=");
var param = new ParametersWithIV(new KeyParameter(keydata), ivdata);
EncryptedXml exml = new EncryptedXml();
byte[] encrypted = exml.EncryptData(body, param, false);
EncryptedData edata = new EncryptedData();
edata.Type = EncryptedXml.XmlEncElementUrl;
edata.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
EncryptedKey ekey = new EncryptedKey();
// omit key encryption, here for testing
byte[] encKeyBytes = keydata;
ekey.CipherData = new CipherData(encKeyBytes);
ekey.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
DataReference dr = new DataReference();
dr.Uri = "_0";
ekey.AddReference(dr);
edata.KeyInfo.AddClause(new KeyInfoEncryptedKey(ekey));
ekey.KeyInfo.AddClause(new RSAKeyValue());
edata.CipherData.CipherValue = encrypted;
EncryptedXml.ReplaceElement(doc.DocumentElement, edata, false);
doc.Save(new XmlTextWriter(sw));
}
// Decryption
{
var aes = CipherUtilities.GetCipher("AES/CBC/ZEROBYTEPADDING");
var random = new SecureRandom();
var ivdata = new byte[aes.GetBlockSize()];
var keydata = Convert.FromBase64String("o/ilseZu+keLBBWGGPlUHweqxIPc4gzZEFWr2nBt640=");
random.NextBytes(ivdata);
var param = new ParametersWithIV(new KeyParameter(keydata), ivdata);
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.LoadXml(sw.ToString());
EncryptedXml encxml = new EncryptedXml(doc);
EncryptedData edata = new EncryptedData();
edata.LoadXml(doc.DocumentElement);
encxml.ReplaceData(doc.DocumentElement, encxml.DecryptData(edata, param));
}
}
}
public InjectObjectFactoryContext(IDictionary <string, object> context)
{
_current = DataReference.CurrentContext();
_field = typeof(DataReference).GetField("_contextScope",
BindingFlags.Static |
BindingFlags.NonPublic);
_field.SetValue(null, context);
}
public ShoppingCart(int productId)
{
using (DataReference db = new DataReference())
{
this.ProductId = productId;
Product p = db.Products.Single(x => x.Id == productId);
this.Name = p.Name;
this.Image = p.Image;
this.Price = double.Parse(p.Price.ToString());
Quantity = 1;
}
}
public void DataReference()
{
IEntity entity = new ContentEntity(0, "");
entity.AddData <DataInt>().A = 1;
DataReference <DataInt> reference = CreateDataReference <DataInt>(entity);
Assert.Equal(1, reference.Current().A);
Assert.Equal(1, reference.Current <DataInt>().A);
Assert.Throws <InvalidOperationException>(() => reference.Current <DataEmpty>());
}
public void WriteTo(XmlDictionaryWriter writer, DictionaryManager dictionaryManager)
{
if (this.DataReferenceCount == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format("ReferenceListCannotBeEmpty")));
}
writer.WriteStartElement(NamespacePrefix, ElementName, NamespaceUri);
for (int i = 0; i < this.DataReferenceCount; i++)
{
DataReference.WriteTo(writer, this.referredIds[i]);
}
writer.WriteEndElement(); // ReferenceList
}
private EncryptedKey CreatedEncryptedKey(SymmetricAlgorithm aes, string dataReferenceId, string keyId)
{
var encryptedKey = new EncryptedKey();
encryptedKey.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSAOAEPUrl);
encryptedKey.Id = keyId;
var cert = new X509Certificate2(certificate);
encryptedKey.CipherData.CipherValue = EncryptedXml.EncryptKey(aes.Key, cert.PublicKey.Key as RSA, true);
var dataReference = new DataReference("#" + dataReferenceId);
encryptedKey.AddReference(dataReference);
return(encryptedKey);
}
public ShortIdEditViewModel(
DataReference dataReference,
IObjectDatabase <ShortId> shortIdDatabase,
IDataApiClient dataApiClient)
{
OriginalId = dataReference.Id;
DataType = dataReference.DataType;
this.shortIdDatabase = shortIdDatabase;
this.dataApiClient = dataApiClient;
ExistingShortIds = new ObservableCollection <ShortId>();
Task.Run(() => LoadExistingShortIds(dataReference));
StoreShortIdCommand = new AsyncRelayCommand(StoreShortId, () => !string.IsNullOrEmpty(UserSpecificId));
}
public static IEnumerable<Archive> GetArchive(DataReference<IPage> blogPage, bool isGlobal)
{
Guid currentPageId = blogPage == null ? PageRenderer.CurrentPageId : blogPage.Data.Id;
IQueryable<Archive> result = DataFacade.GetData<Entries>()
.Where(c => isGlobal ? c.PageId != null : c.PageId == currentPageId)
.GroupBy(c => new {c.Date.Year, c.Date.Month})
.Select(
b =>
new Archive
{
Date = new DateTime(b.Key.Year, b.Key.Month, 1),
Count = b.Select(x => x.Date.Year).Count()
});
return result.OrderByDescending(e => e.Date);
}
private static IMediaFileFolder GetMediaFolder(DataReference <IMediaFileFolder> mediaFolderReference)
{
string mediaFolderKeyPath = mediaFolderReference.KeyValue as string;
using (new DataScope(DataScopeIdentifier.Public))
{
var query = DataFacade.GetData <IMediaFileFolder>();
if (query.IsEnumerableQuery())
{
return(query.AsEnumerable().Where(mf => mf.KeyPath == mediaFolderKeyPath).FirstOrDefault());
}
return(query.Where(mf => mf.KeyPath == mediaFolderKeyPath).FirstOrDefault());
}
}
public static IEnumerable <Archive> GetArchive(DataReference <IPage> blogPage, bool isGlobal)
{
Guid currentPageId = blogPage == null ? PageRenderer.CurrentPageId : blogPage.Data.Id;
IQueryable <Archive> result = DataFacade.GetData <Entries>()
.Where(c => isGlobal ? c.PageId != null : c.PageId == currentPageId)
.GroupBy(c => new { c.Date.Year, c.Date.Month })
.Select(
b =>
new Archive
{
Date = new DateTime(b.Key.Year, b.Key.Month, 1),
Count = b.Select(x => x.Date.Year).Count()
});
return(result.OrderByDescending(e => e.Date));
}
public static AmmoTemplate GetTemplate(DataReference dRef)
{
if (_templates.Count == 0)
{
Init();
}
if (_templates.TryGetValue(dRef.Value.ID, out var data))
{
return(data);
}
if (_templates.TryGetValue(dRef.Value.FullID, out data))
{
return(data);
}
Debug.LogFormat("No ammo {0}", dRef.TargetID);
return(null);
}
public void ReadFrom(XmlDictionaryReader reader)
{
reader.ReadStartElement(ElementName, NamespaceUri);
while (reader.IsStartElement())
{
string item = DataReference.ReadFrom(reader);
if (this.referredIds.Contains(item))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(System.ServiceModel.SR.GetString("InvalidDataReferenceInReferenceList", new object[] { "#" + item })));
}
this.referredIds.Add(item);
}
reader.ReadEndElement();
if (this.DataReferenceCount == 0)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(System.ServiceModel.SR.GetString("ReferenceListCannotBeEmpty")));
}
}
private void Awake()
{
var gm = GameManager.Instance;
score = gm.Score;
coins = gm.Coins;
levelBounds = gm.LevelBounds;
player = gm.Player.transform;
spawnPool = new SpawnPool(2, coinSettings.Value.CoinPrefab);
spawnPool.EnqueueAll();
var queue = spawnPool.QueuedObjects;
for (int i = 0; i < queue.Length; i++)
{
InitializeCoin(queue[i]);
}
}
public override object Execute(ParameterList parameters, FunctionContextContainer context)
{
SitemapScope SitemapScope = parameters.GetParameter <SitemapScope>("SitemapScope");
DataReference <IPage> pageReference = parameters.GetParameter <DataReference <IPage> >("SourcePage");
Guid pageId;
if (pageReference != null && pageReference.IsSet)
{
pageId = (Guid)pageReference.KeyValue;
}
else
{
pageId = PageRenderer.CurrentPageId;
}
return(PageStructureInfo.GetSitemapByScope(SitemapScope, pageId));
}
public void ReadFrom(XmlDictionaryReader reader)
{
reader.ReadStartElement(ElementName, NamespaceUri);
while (reader.IsStartElement())
{
string id = DataReference.ReadFrom(reader);
if (this.referredIds.Contains(id))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new Exception(SR.Format("InvalidDataReferenceInReferenceList", "#" + id)));
}
this.referredIds.Add(id);
}
reader.ReadEndElement(); // ReferenceList
if (this.DataReferenceCount == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new Exception(SR.Format("ReferenceListCannotBeEmpty")));
}
}
public void ReadFrom(XmlDictionaryReader reader)
{
reader.ReadStartElement(ElementName, NamespaceUri);
while (reader.IsStartElement())
{
string id = DataReference.ReadFrom(reader);
if (_referredIds.Contains(id))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new SecurityMessageSerializationException(string.Format(SR_IdentityModel.InvalidDataReferenceInReferenceList, "#" + id)));
}
_referredIds.Add(id);
}
reader.ReadEndElement(); // ReferenceList
if (this.DataReferenceCount == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityMessageSerializationException(SR_IdentityModel.ReferenceListCannotBeEmpty));
}
}
public static IEnumerable<Tag> GetTagCloud(double minFontSize, double maxFontSize, DataReference<IPage> blogPage,
bool isGlobal)
{
Guid currentPageId = blogPage == null ? PageRenderer.CurrentPageId : blogPage.Data.Id;
if (isGlobal)
{
currentPageId = Guid.Empty;
}
List<string> blog = currentPageId == Guid.Empty
? DataFacade.GetData<Entries>().Select(b => b.Tags).ToList()
: DataFacade.GetData<Entries>()
.Where(b => b.PageId == currentPageId)
.Select(b => b.Tags)
.ToList();
var dcTags = new Dictionary<string, int>();
foreach (
string tag in
blog.Where(b => !string.IsNullOrEmpty(b)).SelectMany(b => b.Split(','), (b, s) => s.Trim()))
{
if (dcTags.ContainsKey(tag))
{
dcTags[tag] = dcTags[tag] + 1;
}
else
{
dcTags.Add(tag, 1);
}
}
return from d in dcTags
let minOccurs = dcTags.Values.Min()
let maxOccurs = dcTags.Values.Max()
let occurrencesOfCurrentTag = d.Value
let weight =
(Math.Log(occurrencesOfCurrentTag) - Math.Log(minOccurs))/
(Math.Log(maxOccurs) - Math.Log(minOccurs))
let fontSize = minFontSize + Math.Round((maxFontSize - minFontSize)*weight)
select new Tag {Title = d.Key, FontSize = fontSize, Rel = d.Value};
}
public static void Encrypt(XmlDocument Doc, string ElementToEncrypt, string EncryptionElementID, RSA Alg, string KeyName)
{
XmlElement elementToEncrypt = Doc.GetElementsByTagName(ElementToEncrypt)[0] as XmlElement;
if (elementToEncrypt == null)
{
throw new XmlException("The specified element was not found");
}
RijndaelManaged sessionKey = null;
try {
sessionKey = new RijndaelManaged();
sessionKey.KeySize = 256;
EncryptedXml eXml = new EncryptedXml();
byte[] encryptedElement = eXml.EncryptData(elementToEncrypt, sessionKey, false);
EncryptedData edElement = new EncryptedData();
edElement.Type = EncryptedXml.XmlEncElementUrl;
edElement.Id = EncryptionElementID;
edElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
EncryptedKey ek = new EncryptedKey();
byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, Alg, false);
ek.CipherData = new CipherData(encryptedKey);
ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
DataReference dRef = new DataReference();
dRef.Uri = "#" + EncryptionElementID;
ek.AddReference(dRef);
edElement.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));
KeyInfoName kin = new KeyInfoName();
kin.Value = KeyName;
ek.KeyInfo.AddClause(kin);
edElement.CipherData.CipherValue = encryptedElement;
EncryptedXml.ReplaceElement(elementToEncrypt, edElement, false);
} catch (Exception e) {
throw e;
} finally {
if (sessionKey != null)
{
sessionKey.Clear();
}
}
}
private static string GetFolderPath(DataReference <IMediaFileFolder> folderReference)
{
if (folderReference != null && folderReference.IsSet)
{
IMediaFileFolder folder;
try
{
folder = folderReference.Data;
if (folder != null)
{
return(folder.Path);
}
}
catch (Exception)
{
string reference = folderReference.Serialize() ?? string.Empty;
LoggingService.LogError(LogTitle, "Failed to get media folder by referece: '{0}'".FormatWith(reference));
}
}
return(null);
}
public UploadedFileViewModel(
string fileName,
FileHandlingStatus status,
string statusText,
string uploadInfoId,
DataReference rawDataReference,
List <DataReference> derivedDataReferences,
IDataApiClient dataApiClient,
List <IDerivedFileDataViewModel> derivedDataViewModels,
IClipboard clipboard)
{
FileName = fileName;
Status = status;
StatusText = statusText;
UploadInfoId = uploadInfoId;
RawDataReference = rawDataReference;
DerivedDataReferences = derivedDataReferences;
this.dataApiClient = dataApiClient;
this.clipboard = clipboard;
DerivedDataViewModels = derivedDataViewModels;
DeleteFileCommand = new AsyncRelayCommand(DeleteFile);
}
/// <summary>
/// Método para criptografia
/// </summary>
/// <param name="doc">XML documento</param>
/// <param name="tagToEncrypt">Tag para criptografia</param>
/// <param name="encryptionElementId">Tag de identificação da criptografia</param>
/// <param name="alg">RSA</param>
/// <param name="keyName">chave para criptografia</param>
public static void Encrypt(XmlDocument doc, string tagToEncrypt, string encryptionElementId, RSA alg, string keyName)
{
if (doc == null)
{
throw new ArgumentNullException("doc");
}
if (tagToEncrypt == null)
{
throw new ArgumentNullException("ElementToEncrypt");
}
if (encryptionElementId == null)
{
throw new ArgumentNullException("encryptionElementId");
}
if (alg == null)
{
throw new ArgumentNullException("alg");
}
if (keyName == null)
{
throw new ArgumentNullException("keyName");
}
////////////////////////////////////////////////
// Find the specified element in the XmlDocument
// object and create a new XmlElemnt object.
////////////////////////////////////////////////
XmlElement elementToEncrypt = doc.GetElementsByTagName(tagToEncrypt)[0] as XmlElement;
// Throw an XmlException if the element was not found.
if (elementToEncrypt == null)
{
throw new XmlException("The specified element was not found");
}
RijndaelManaged sessionKey = null;
try
{
//////////////////////////////////////////////////
// Create a new instance of the EncryptedXml class
// and use it to encrypt the XmlElement with the
// a new random symmetric key.
//////////////////////////////////////////////////
// Create a 256 bit Rijndael key.
sessionKey = new RijndaelManaged();
sessionKey.KeySize = 256;
EncryptedXml eXml = new EncryptedXml();
byte[] encryptedElement = eXml.EncryptData(elementToEncrypt, sessionKey, false);
////////////////////////////////////////////////
// Construct an EncryptedData object and populate
// it with the desired encryption information.
////////////////////////////////////////////////
EncryptedData edElement = new EncryptedData();
edElement.Type = EncryptedXml.XmlEncElementUrl;
edElement.Id = encryptionElementId;
// Create an EncryptionMethod element so that the
// receiver knows which algorithm to use for decryption.
edElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
// Encrypt the session key and add it to an EncryptedKey element.
EncryptedKey ek = new EncryptedKey();
byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, alg, false);
ek.CipherData = new CipherData(encryptedKey);
ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
// Create a new DataReference element
// for the KeyInfo element. This optional
// element specifies which EncryptedData
// uses this key. An XML document can have
// multiple EncryptedData elements that use
// different keys.
DataReference dRef = new DataReference();
// Specify the EncryptedData URI.
dRef.Uri = "#" + encryptionElementId;
// Add the DataReference to the EncryptedKey.
ek.AddReference(dRef);
// Add the encrypted key to the
// EncryptedData object.
edElement.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));
// Set the KeyInfo element to specify the
// name of the RSA key.
// Create a new KeyInfoName element.
KeyInfoName kin = new KeyInfoName();
// Specify a name for the key.
kin.Value = keyName;
// Add the KeyInfoName element to the
// EncryptedKey object.
ek.KeyInfo.AddClause(kin);
// Add the encrypted element data to the
// EncryptedData object.
edElement.CipherData.CipherValue = encryptedElement;
////////////////////////////////////////////////////
// Replace the element from the original XmlDocument
// object with the EncryptedData element.
////////////////////////////////////////////////////
EncryptedXml.ReplaceElement(elementToEncrypt, edElement, false);
}
catch (Exception e)
{
// re-throw the exception.
throw e;
}
finally
{
if (sessionKey != null)
{
sessionKey.Clear();
}
}
}
private static string GetFolderPath(DataReference<IMediaFileFolder> folderReference)
{
if (folderReference != null && folderReference.IsSet)
{
IMediaFileFolder folder;
try
{
folder = folderReference.Data;
if (folder != null)
{
return folder.Path;
}
}
catch (Exception)
{
string reference = folderReference.Serialize() ?? string.Empty;
LoggingService.LogError(LogTitle, "Failed to get media folder by referece: '{0}'".FormatWith(reference));
}
}
return null;
}
private async Task <UploadedFileViewModel> HandleSingleFile(
byte[] fileData,
string fileName,
string dataProjectId,
string uploaderInitials)
{
var extension = Path.GetExtension(fileName)?.ToLowerInvariant();
if (extension == null)
{
throw new Exception("File has no extension");
}
var matchingFileHandlers = fileHandlers.ContainsKey(extension)
? fileHandlers[extension]
: new List <IFileHandler>();
var dataBlob = DataBlobBuilder.FromByteArray(fileData, fileName);
FileHandlingStatus fileStatus;
if (await dataBlobDatabase.ExistsAsync(dataBlob.Id))
{
fileStatus = FileHandlingStatus.AlreadyExists;
}
else
{
await dataBlobDatabase.StoreAsync(dataBlob);
fileStatus = FileHandlingStatus.Success;
}
Dictionary <string, object> additionalInformation = null;
if (matchingFileHandlers.Any(x => x.RequiresAdditionalInformation))
{
var additionalInformationRequiringFileHandlers = matchingFileHandlers.Where(x => x.RequiresAdditionalInformation).ToList();
var requestResult = await RequestAdditionalInformation(additionalInformationRequiringFileHandlers, fileName);
if (!requestResult.IsRequestCompleted)
{
return(UploadedFileViewModel.Failed(fileName, "Not enough information provided"));
}
additionalInformation = requestResult.AdditionalInformationObjects;
}
var rawDataReference = DataReference.FromIId(dataBlob);
var fileViewModels = new List <IDerivedFileDataViewModel>();
var derivedDataReferences = new List <DataReference>();
foreach (var matchingFileHandler in matchingFileHandlers)
{
var fileHandlerType = matchingFileHandler.GetType().Name;
var fileHandlerAdditionalInformation = additionalInformation.ContainsKey(fileHandlerType)
? additionalInformation[fileHandlerType]
: null;
var fileHandlerResult = await matchingFileHandler.Handle(fileData, fileName, dataProjectId, fileHandlerAdditionalInformation);
fileViewModels.AddRange(fileHandlerResult.ViewModels);
derivedDataReferences.AddRange(fileHandlerResult.DerivedDataReferences);
}
var uploadInfo = new DataProjectUploadInfo(
uploaderInitials,
DateTime.UtcNow,
dataProjectId,
rawDataReference,
derivedDataReferences,
fileName);
await dataProjectUploadInfoDatabase.StoreAsync(uploadInfo);
return(new UploadedFileViewModel(
fileName,
fileStatus,
string.Empty,
uploadInfo.Id,
rawDataReference,
derivedDataReferences,
dataApiClient,
fileViewModels,
clipboard));
}
/// <summary>
/// Returns a URL for a specific C1 page
/// </summary>
/// <param name="page">The page.</param>
/// <returns></returns>
public IHtmlString PageUrl(DataReference<IPage> page)
{
return PageUrl(((Guid) page.KeyValue));
}
public static IEnumerable<DataReferenceLabelPair<IMediaFile>> GenerateSelectorOptions(string key)
{
string folderString = key.Split('?')[0];
string extensionFilter = key.Split('?')[1];
bool includeSubfolders = bool.Parse(key.Split('?')[2]);
IQueryable<IMediaFile> queryable = DataFacade.GetData<IMediaFile>();
bool filterByFolder = !folderString.IsNullOrEmpty();
IMediaFileFolder folder = null;
if (filterByFolder)
{
var folderReference = new DataReference<IMediaFileFolder>(folderString);
folder = folderReference.Data;
string storeId = folder.StoreId;
queryable = queryable.Where(mediaFile => mediaFile.StoreId == storeId);
string folderPath = folder.Path;
if (!includeSubfolders)
{
queryable = queryable.Where(mediaFile => mediaFile.FolderPath == folderPath);
}
else
{
string descFolderPrefix = folderPath + "/";
queryable = queryable.Where(mediaFile => mediaFile.FolderPath == folderPath || mediaFile.FolderPath.StartsWith(descFolderPrefix));
}
}
if (!extensionFilter.IsNullOrEmpty())
{
Expression<Func<IMediaFile, bool>> filter = GetExtensionFilter(extensionFilter);
if (filter != null)
{
queryable = queryable.Where(filter);
}
}
// orderby mediaFile.StoreId, mediaFile.FolderPath, mediaFile.FileName
queryable = queryable.OrderBy(file => file.StoreId).ThenBy(file => file.FolderPath).ThenBy(file => file.FileName);
if (filterByFolder)
{
int pathLength = folder.Path.Length;
return from mediaFile in queryable
select new DataReferenceLabelPair<IMediaFile>(mediaFile, mediaFile.FolderPath.Substring(pathLength) + "/" + mediaFile.FileName);
}
return from mediaFile in queryable
select new DataReferenceLabelPair<IMediaFile>(mediaFile, mediaFile.StoreId + ":" + mediaFile.FolderPath + "/" + mediaFile.FileName);
}
/// <summary>
/// Returns a media url.
/// </summary>
/// <param name="image">The image file.</param>
/// <param name="resizingOptions">The resizing options.</param>
/// <returns></returns>
public IHtmlString MediaUrl(DataReference<IImageFile> image, ResizingOptions resizingOptions)
{
return MediaUrl((string) image.KeyValue, resizingOptions);
}
/// <summary>
/// Returns a media url.
/// </summary>
/// <param name="image">The image file.</param>
/// <returns></returns>
public IHtmlString MediaUrl(DataReference<IImageFile> image)
{
return MediaUrl((string)image.KeyValue);
}
/// <summary>
/// Returns a media url.
/// </summary>
/// <param name="mediaFile">The media file.</param>
/// <returns></returns>
public IHtmlString MediaUrl(DataReference<IMediaFile> mediaFile)
{
return MediaUrl((string) mediaFile.KeyValue);
}
// Methods
public void AddReference(DataReference dataReference) {}
public static string LoadFileFromMedia(DataReference<IMediaFile> mediaFileReference)
{
return mediaFileReference.Data.ReadAllText();
}
