private static Uri ExecuteAssetDeleteRequest( AssetDeleteOptionsRequestAdapter adapter)
{
Uri uri = null;
var context = new DataServiceContext(new Uri("http://127.0.0.1/" + Guid.NewGuid().ToString()));
bool sendingRequestCalled = false;
context.SendingRequest2 += delegate(object o, SendingRequest2EventArgs args)
{
sendingRequestCalled = true;
uri = args.RequestMessage.Url;
};
try
{
AssetData asset = new AssetData() {Id = Guid.NewGuid().ToString()};
context.AttachTo("Assets", asset);
context.DeleteObject(asset);
adapter.Adapt(context);
context.SaveChanges();
}
catch (DataServiceRequestException ex)
{
Debug.WriteLine(ex.Message);
}
Assert.IsTrue(sendingRequestCalled);
return uri;
}
static List<AssetData> Load()
{
var assetlist = new List<AssetData>();
var files = Directory.GetFiles("Assets", "ImportPackages*.imp", SearchOption.AllDirectories);
foreach( var file in files ){
var text = File.ReadAllText(file);
var textReader = new System.IO.StringReader(text);
var url = textReader.ReadLine();
var assetData = new AssetData();
assetData.asseturl = url;
assetlist.Add(assetData);
while( textReader.Peek() > -1 ){
var strs = textReader.ReadLine().Split(',');
var guid = strs[1];
var requestFilePath = strs[0];
var filePath = AssetDatabase.GUIDToAssetPath( guid );
if( string.IsNullOrEmpty( filePath ) || File.Exists(filePath) == false ){
assetData.pathList.Add(requestFilePath);
}
}
}
return assetlist;
}
public void LinkCollectionTestRemoveRetry()
{
var data = new AssetData { };
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 2, data);
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
data.SetMediaContext(_mediaContext);
var target = new LinkCollection<IAsset, AssetData>(dataContextMock.Object, data, "", new IAsset[] { data });
target.RemoveAt(0);
dataContextMock.Verify((ctxt) => ctxt.SaveChanges(), Times.Exactly(2));
}
public void GivenExistentAssetDataWithoutLocationOrManifest()
{
AssetData expectedPackageAssetNoLocationOrManifest =
new AssetData(true)
{
Locations = ImmutableList.Create(
new AssetLocationData(LocationType.Container)
{
Location = ""
}),
Name = "assets/manifests/thisIsARepo/1.2.3-beta.1235.6/",
Version = "1.2.3-beta.1235.6"
};
AssetData parsedAssets = pushMetadata.GetManifestAsAsset(ImmutableList.Create(PackageAsset1), "", "");
parsedAssets.Should().BeEquivalentTo(expectedPackageAssetNoLocationOrManifest);
}
protected AssetBundle LoadRawAssetBundle(string abname)
{
string path = GetAssetPath(abname);
AssetBundle ab = AssetBundle.LoadFromFile(path);
if (ab != null)
{
Util.Log("Load AssetBundle: " + path);
AssetData asset = new AssetData();
asset.assetbundle = ab;
asset.reference++;
mAssetCache.Add(abname, asset);
return(ab);
}
Util.Log("Load AssetBundle failed: " + path);
return(null);
}
public Player(AssetData assetData)
{
this.Name = "Player";
this.TotalHP = 100;
this.HP = this.TotalHP;
this.Level = 1;
this.XP = 0;
this.spriteAssetData = new SpriteAssetData("Player", 0);
this.avatarSprite = assetData.getSprite(this.spriteAssetData);
itemList = new List <Item> ();
itemList.Add(ItemFactory.getHealingPotion(assetData));
itemList.Add(ItemFactory.getRegenPotion(assetData));
itemList.Add(ItemFactory.getGrenade(assetData));
itemList.Add(ItemFactory.getPoison(assetData));
}
public void LinkCollectionTestRemoveRetry()
{
var data = new AssetData {
};
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 2, data);
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
data.SetMediaContext(_mediaContext);
var target = new LinkCollection <IAsset, AssetData>(dataContextMock.Object, data, "", new IAsset[] { data });
target.RemoveAt(0);
dataContextMock.Verify((ctxt) => ctxt.SaveChanges(), Times.Exactly(2));
}
public void TestIngestManifestAssetCreateRetry()
{
var asset = new AssetData { Name = "testData", Id = "testId" };
var expected = new IngestManifestAssetData { Asset = asset };
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 2, expected);
dataContextMock.Setup((ctxt) => ctxt.AddObject("IngestManifestAssets", It.IsAny<object>()));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
var parent = new IngestManifestData { };
var target = new IngestManifestAssetCollection(_mediaContext, parent);
var actual = target.CreateAsync(asset, CancellationToken.None).Result;
Assert.AreEqual(expected.Asset.Name, actual.Asset.Name);
dataContextMock.Verify((ctxt) => ctxt.SaveChangesAsync(It.IsAny<object>()), Times.Exactly(2));
}
public override bool TryGetValue(UUID key, out AssetData asset)
{
asset = null;
using (var conn = new SqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new SqlCommand("SELECT TOP(1) * FROM assetrefs INNER JOIN assetdata ON assetrefs.hash = assetdata.hash AND assetrefs.assetType = assetdata.assetType WHERE id = @id", conn))
{
cmd.Parameters.AddParameter("@id", key);
using (SqlDataReader dbReader = cmd.ExecuteReader())
{
if (!dbReader.Read())
{
return(false);
}
asset = new AssetData
{
ID = dbReader.GetUUID("id"),
Data = dbReader.GetBytes("data"),
Type = dbReader.GetEnum <AssetType>("assetType"),
Name = (string)dbReader["name"],
CreateTime = dbReader.GetDate("create_time"),
AccessTime = dbReader.GetDate("access_time"),
Flags = dbReader.GetEnum <AssetFlags>("asset_flags"),
Temporary = (bool)dbReader["temporary"]
};
}
}
if (DateTime.UtcNow - asset.AccessTime > TimeSpan.FromHours(1))
{
/* update access_time */
using (var cmd = new SqlCommand("UPDATE assetrefs SET access_time = @access WHERE id = @id", conn))
{
cmd.Parameters.AddWithValue("@access", Date.GetUnixTime());
cmd.Parameters.AddWithValue("@id", key);
cmd.ExecuteNonQuery();
}
}
return(true);
}
}
//获取加载进度
internal override float __GetProgress(string url_)
{
AssetData data = GetData(url_);
if (data == null)
{
return(0);
}
//if (m_url2req.ContainsKey(url_))
// return m_url2req[url_].progress;
if (data.asset != null)
{
return(1);
}
return(0);
}
public Notecard this[UUID assetid]
{
get
{
Notecard v;
if (m_Notecards.TryGetValue(assetid, out v))
{
return(v);
}
AssetData asset = m_Scene.AssetService[assetid];
if (asset.Type != AssetType.Notecard)
{
throw new NotANotecardFormatException();
}
m_LastAccessed[assetid] = Environment.TickCount;
return(m_Notecards.GetOrAddIfNotExists(assetid, () => new Notecard(asset)));
}
}
static void Test()
{
SqlServer sql = new SqlServer();
sql.CreateAccountTable(true);
PlayerData data = new PlayerData();
data._accountName = "1";
data._nickName = "11";
data._blockIdsInUse = new int[] { 1
// , 2, 3
};
sql.Register(data, "1");
data._accountName = "2";
data._nickName = "22";
data._blockIdsInUse = new int[] { 3
// , 4, 5
};
sql.Register(data, "1");
sql.CreateAssetTable(true);
AssetData a = new AssetData();
a._accountName = "1";
a._gold = 10;
a._blocks = new int[] { 1, 2, 3 };
a._blockBoards = new int[] { 0, 1, 2 };
a._boards = new int[] { 0, 1, 2 };
a._persons = new int[] { 0, 1, 2 };
sql.ChangeAsset(a);
a._accountName = "2";
a._gold = 10;
a._blocks = new int[] { 3, 4, 5 };
a._blockBoards = new int[] { 0 };
a._boards = new int[] { 0 };
a._persons = new int[] { 0, 2 };
sql.ChangeAsset(a);
//var s = sql.GetAssetData("1");
//sql.CreateAccountTable();
}
internal static Font AssignFontOnChildren(GameObject go, AssetData data)
{
var text = go.GetComponentInChildren <TextMesh>();
if (text != null)
{
var font = (Font)data.asset;
#if UNITY_EDITOR
Undo.RecordObject(go, k_AssignFontUndo);
#endif
text.font = font;
return(font);
}
return(null);
}
public void Asset_Create_Sprite_ShouldCreateTextureAssetFileAndSpriteAssetFileInTheSameFolderAsTextureFile_GivenTextureFilePath()
{
// Arrange
var pngFilePathToCopy = Utils.GetPathUnderTestDirectory(@"Assets\TestTexture.png");
var pngFilePathInTempDir = Path.Combine(_temporaryDirectory.Path, "TestTexture.png");
File.Copy(pngFilePathToCopy, pngFilePathInTempDir);
// Act
RunGeishaCli($"asset create sprite \"{pngFilePathInTempDir}\"");
// Assert
var textureAssetFilePath = Path.Combine(_temporaryDirectory.Path, AssetFileUtils.AppendExtension("TestTexture"));
Assert.That(File.Exists(textureAssetFilePath), Is.True, "Texture asset file was not created.");
var textureAssetData = AssetData.Load(textureAssetFilePath);
Assert.That(textureAssetData.AssetId, Is.Not.EqualTo(Guid.Empty));
Assert.That(textureAssetData.AssetType, Is.EqualTo(RenderingAssetTypes.Texture));
var textureAssetContent = textureAssetData.ReadJsonContent <TextureAssetContent>();
Assert.That(textureAssetContent.TextureFilePath, Is.EqualTo("TestTexture.png"));
var spriteAssetFilePath = Path.Combine(_temporaryDirectory.Path, AssetFileUtils.AppendExtension("TestTexture.sprite"));
Assert.That(File.Exists(spriteAssetFilePath), Is.True, "Sprite asset file was not created.");
var spriteAssetData = AssetData.Load(spriteAssetFilePath);
Assert.That(spriteAssetData.AssetId, Is.Not.EqualTo(Guid.Empty));
Assert.That(spriteAssetData.AssetType, Is.EqualTo(RenderingAssetTypes.Sprite));
var spriteAssetContent = spriteAssetData.ReadJsonContent <SpriteAssetContent>();
Assert.That(spriteAssetContent.TextureAssetId, Is.EqualTo(textureAssetData.AssetId.Value));
Assert.That(spriteAssetContent.SourceUV.X, Is.Zero);
Assert.That(spriteAssetContent.SourceUV.Y, Is.Zero);
Assert.That(spriteAssetContent.SourceDimensions.X, Is.EqualTo(10));
Assert.That(spriteAssetContent.SourceDimensions.Y, Is.EqualTo(10));
Assert.That(spriteAssetContent.Pivot.X, Is.EqualTo(5));
Assert.That(spriteAssetContent.Pivot.Y, Is.EqualTo(5));
Assert.That(spriteAssetContent.PixelsPerUnit, Is.EqualTo(1));
}
public void TestAssetUpdateRetry()
{
var data = new AssetData {
Name = "testData"
};
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 2, data);
dataContextMock.Setup((ctxt) => ctxt.AttachTo("Assets", data));
dataContextMock.Setup((ctxt) => ctxt.UpdateObject(data));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
data.SetMediaContext(_mediaContext);
data.Update();
dataContextMock.Verify((ctxt) => ctxt.SaveChangesAsync(data), Times.Exactly(2));
}
/// <summary>
/// 资源加载
/// </summary>
/// <param name="assetName"></param>
/// <param name="type"></param>
/// <param name="isKeep"></param>
/// <returns></returns>
public static IEnumerator LoadAsset(string assetName, AssetType type, bool isKeep)
{
if (!cacheAsset.ContainsKey(assetName))
{
string path = string.Empty;
switch (type)
{
case AssetType.Scene:
path = "Scene/";
break;
case AssetType.Model:
path = "Model/";
break;
case AssetType.UI:
path = "UI/";
break;
case AssetType.Effect:
path = "Effect/";
break;
case AssetType.Audio:
path = "Audio/";
break;
}
string assetPath = Util.AppContentDataUri + path + assetName + "unity3d";
#if UNITY_EDITOR
Object asset = Resources.LoadAssetAtPath("Asset/Prefabs/" + path + assetName + "prefab", typeof (GameObject));
#else
WWW www = new WWW(assetPath);
yield return www;
Object asset = www.assetBundle.mainAsset;
//www.assetBundle.Unload(false);
#endif
AssetData assetData = new AssetData(); //将加载的资源缓存
assetData.asset = asset;
assetData.isKeep = isKeep;
cacheAsset.Add(assetName, assetData);
}
yield return null; //只是加载并没有获取
}
public void GivenEmptyAssetDataList()
{
AssetData expectedPackageAssetNoAssets =
new AssetData(true)
{
Locations = ImmutableList.Create(
new AssetLocationData(LocationType.Container)
{
Location = locationString
}),
Name = $"assets/manifests/thisIsARepo//{newManifestName}",
NonShipping = true,
Version = null
};
AssetData parsedAssets = pushMetadata.GetManifestAsAsset(ImmutableList.Create <AssetData>(), locationString, newManifestName);
parsedAssets.Should().BeEquivalentTo(expectedPackageAssetNoAssets);
}
private static bool CheckAssetDataIsMatchSpriteHolder(AssetData assetData, SpriteHolder spriteHolder)
{
bool isSame = true;
foreach (var data in spriteHolder.injections)
{
string key = data.name;
HolderData hd = assetData.GetAssetByKey(key);
if (hd == null)
{
return(false);
}
if (((Object)data.value) != hd.asset)
{
return(false);
}
}
return(isSame);
}
public object LoadAsset(AssetInfo assetInfo, IAssetStore assetStore)
{
using var fileStream = _fileSystem.GetFile(assetInfo.AssetFilePath).OpenRead();
var assetData = AssetData.Load(fileStream);
var spriteAnimationAssetContent = assetData.ReadJsonContent <SpriteAnimationAssetContent>();
if (spriteAnimationAssetContent.Frames == null)
{
throw new InvalidOperationException($"{nameof(SpriteAnimationAssetContent)}.{nameof(SpriteAnimationAssetContent.Frames)} cannot be null.");
}
var frames = spriteAnimationAssetContent.Frames.Select(f =>
{
var sprite = assetStore.GetAsset <Sprite>(new AssetId(f.SpriteAssetId));
return(new SpriteAnimationFrame(sprite, f.Duration));
}).ToArray();
return(new SpriteAnimation(frames, TimeSpan.FromTicks(spriteAnimationAssetContent.DurationTicks)));
}
public void GivenSomeAssetsInBlobSetAndSomeNot()
{
BuildModel expectedBuildModel = GetBuildModel();
PushMetadataToBuildAssetRegistry pushMetadata = GetPushMetadata();
AssetData dataInBlobSet = pushMetadata.GetManifestAsAsset(ImmutableList.Create(nonShippingAssetData), "thisIsALocation", "thisIsTheManifestFileName");
PackageArtifactModel shippingPackageArtifact = new PackageArtifactModel
{
Attributes = new Dictionary <string, string>
{
{ "NonShipping", "false" },
},
Id = shippingAssetData.Name,
Version = shippingAssetData.Version
};
BlobArtifactModel blobArtifactModel = new BlobArtifactModel
{
Attributes = new Dictionary <string, string>
{
{ "NonShipping", "true" }
},
Id = dataInBlobSet.Name
};
expectedBuildModel.Artifacts =
new ArtifactSet
{
Packages = new List <PackageArtifactModel> {
shippingPackageArtifact
},
Blobs = new List <BlobArtifactModel> {
blobArtifactModel
}
};
BuildModel actualModel = pushMetadata.CreateMergedManifestBuildModel(
ImmutableList.Create(dataInBlobSet, shippingAssetData), manifestBuildData);
actualModel.Should().BeEquivalentTo(expectedBuildModel);
}
public static AssetData LoadAsset(
this TarArchiveReader reader,
TarArchiveReader.Header hdr,
UGUI creator)
{
var asset = new AssetData
{
ID = UUID.Parse(hdr.FileName.Substring(7, 36)),
FileName = hdr.FileName,
Name = "From Archive",
Data = new byte[hdr.Length]
};
if (hdr.Length != reader.Read(asset.Data, 0, hdr.Length))
{
throw new IOException();
}
return(asset);
}
//variance = -1 to 1. will scale the difficulty of the enemy
public static Enemy GenerateEnemy(int level, float variance, AssetData assetData)
{
level = Mathf.Clamp(Core.vary(level, variance), 1, Enemy.MaxLevel);
string type = getType(level);
string name = getName(type, variance);
var e = new Enemy(name, level);
e.type = type;
e.TotalHP = Mathf.Clamp(Core.vary(e.TotalHP, variance), Enemy.MinHp, Enemy.MaxHp);
e.HP = e.TotalHP;
e.Damage = Mathf.Clamp(Core.vary(e.Damage, variance), Enemy.MinDmg, Enemy.MaxDmg);
e.Gold = Mathf.Clamp(Core.vary(e.Gold, variance), 0, 99999);
e.ItemList = ItemFactory.GenerateLoot(level, variance, assetData);
e.XP = Mathf.Clamp(e.XP + Mathf.RoundToInt(e.XP * variance), 10, 9999999);
e.avatarSprite = getSprite(e.type, assetData);
e.turnDataList = generateTurnDataList(level, variance);
return(e);
}
public LLMesh(AssetData asset)
{
m_AssetData = asset.Data;
if (asset.Type != AssetType.Mesh)
{
throw new NotAMeshFormatException();
}
try
{
using (Stream s = asset.InputStream)
{
m_MeshData = (Map)LlsdBinary.Deserialize(s);
m_EndOfHeader = (int)s.Position;
}
}
catch
{
throw new NotAMeshFormatException();
}
}
void Start()
{
canvas = (Canvas)FindObjectOfType(typeof(Canvas));
gameController = (GameController)FindObjectOfType(typeof(GameController));
assets = gameController.assets;
// determine which method we should use on update based on our game type (Local vs Networked)
if (ApplicationData.GameMode == ApplicationData.GameModes.Local)
{
updateInterface = new UpdateUserInterface(UpdateInterfaceLocal);
}
else if (ApplicationData.GameMode == ApplicationData.GameModes.Networked)
{
P2EnergyBarMask.showMaskGraphic = false;
P2EnergyBarFill.enabled = false;
P2EnergyBar.enabled = false;
updateInterface = new UpdateUserInterface(UpdateInterfaceNetworked);
}
}
public void GivenAssetVersionIsSet_VersionDoesntChange()
{
AssetData packageAsset1DifferentVersion =
new AssetData(true)
{
Locations = ImmutableList.Create(
new AssetLocationData(LocationType.Container)
{
Location = locationString
}),
Name = "PackageAsset1Name",
Version = "123456"
};
// Version is set on the first pass through the function, then persisted in the class instance so changing it should have no effect on the generated AssetData
pushMetadata.GetManifestAsAsset(ImmutableList.Create(PackageAsset1), "thisIsALocation", "FirstManifest");
AssetData secondPassAssets = pushMetadata.GetManifestAsAsset(ImmutableList.Create(packageAsset1DifferentVersion), locationString, newManifestName);
secondPassAssets.Should().BeEquivalentTo(ExpectedPackageAsset1);
}
public void LoadAsset(AssetData asset)
{
switch (asset.assetType)
{
case "3d":
ModelFetcher.GetComponent <ModelFetcher>().Url = asset.link;
_gameObject = GameObject.Instantiate(ModelFetcher, Vector3.zero, Quaternion.identity, Placeholder.transform);
_gameObject.transform.localPosition = Vector3.zero;
_gameObject.transform.localRotation = Quaternion.identity;
_gameObject.GetComponent <ModelFetcher>().OnLoaded += () => {
_animator.SetTrigger("place");
};
break;
case "image":
ImageFetcher.GetComponent <ImageFetcher>().Url = asset.link;
_gameObject = GameObject.Instantiate(ImageFetcher, Vector3.zero, Quaternion.identity, Placeholder.transform);
_gameObject.transform.localPosition = Vector3.zero;
_gameObject.transform.localRotation = Quaternion.identity;
_gameObject.GetComponent <ImageFetcher>().OnLoaded += () => {
_animator.SetTrigger("place");
};
break;
case "video":
VideoFetcher.GetComponent <VideoFetcher>().Url = asset.link;
_gameObject = GameObject.Instantiate(VideoFetcher, Vector3.zero, Quaternion.identity, Placeholder.transform);
_gameObject.transform.localPosition = Vector3.zero;
_gameObject.transform.localRotation = Quaternion.identity;
_gameObject.GetComponent <VideoFetcher>().OnLoaded += () => {
_animator.SetTrigger("place");
};
break;
default:
Debug.Log("Cannot handle asset of type " + asset.assetType);
break;
}
_asset = asset;
_animator.SetTrigger("place");
}
public void SetUp()
{
var renderingBackend = Substitute.For <IRenderingBackend>();
var renderer2D = Substitute.For <IRenderer2D>();
var fileSystem = Substitute.For <IFileSystem>();
_assetStore = Substitute.For <IAssetStore>();
renderingBackend.Renderer2D.Returns(renderer2D);
const string assetFilePath = @"some_directory\texture_file_path";
const string textureFilePath = @"some_directory\actual_texture_file_path";
var textureAssetContent = new TextureAssetContent
{
TextureFilePath = "actual_texture_file_path"
};
_assetInfo = new AssetInfo(AssetId.CreateUnique(), RenderingAssetTypes.Texture, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(_assetInfo.AssetId, _assetInfo.AssetType, textureAssetContent);
var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
fileSystem.GetFile(assetFilePath).Returns(assetFile);
var stream = Substitute.For <Stream>();
var textureFile = Substitute.For <IFile>();
textureFile.OpenRead().Returns(stream);
fileSystem.GetFile(textureFilePath).Returns(textureFile);
_texture = Substitute.For <ITexture>();
renderer2D.CreateTexture(stream).Returns(_texture);
_textureAssetLoader = new TextureAssetLoader(renderingBackend, fileSystem);
}
public void HoverButton()
{
var index = transform.GetSiblingIndex();
if (craftingTable)
{
if (!craftingTable.breakingDown)
{
if (craftBlueprintData == null && C.c.data.craftingBlueprintList.Count > 0)
{
craftBlueprintData = C.c.data.craftingBlueprintList[index];
}
if (craftBlueprintData)
{
pui.invRender.UpdateAssetPreview(craftBlueprintData);
string txt = "";
foreach (AssetData a in craftBlueprintData.craftingMaterials)
{
txt += "x1 " + a.name + "\n";
}
pui.craftingPanel.transform.Find("RequiredComponentsPanel").GetChild(0).GetComponent <TextMeshProUGUI>().text = txt;
}
else
{
pui.invRender.UpdateAssetPreview(null);
}
}
else
{
if (pui.player.inventory[index].amount > 0)
{
invSlotForBreakdown = index;
pui.invRender.UpdateAssetPreview(pui.player.inventory[index].asset);
}
else
{
pui.invRender.UpdateAssetPreview(null);
}
}
}
}
Asset_Create_InputMapping_ShouldRecreateDefaultInputMappingAssetFileWithTheSameAssetId_WhenInputMappingAssetFileAlreadyExists_GivenKeepAssetId()
{
// Arrange
var inputMappingAssetFilePath = Path.Combine(_temporaryDirectory.Path, AssetFileUtils.AppendExtension("DefaultInputMapping"));
RunGeishaCli("asset create input-mapping", _temporaryDirectory.Path);
var originalAssetData = AssetData.Load(inputMappingAssetFilePath);
var modifiedAssetData = AssetData.CreateWithJsonContent(originalAssetData.AssetId, originalAssetData.AssetType, new InputMappingAssetContent());
modifiedAssetData.Save(inputMappingAssetFilePath);
// Act
RunGeishaCli("asset create input-mapping --keep-asset-id", _temporaryDirectory.Path);
// Assert
var actualAssetData = AssetData.Load(inputMappingAssetFilePath);
Assert.That(actualAssetData.AssetId, Is.EqualTo(originalAssetData.AssetId));
Assert.That(actualAssetData.ReadJsonContent <InputMappingAssetContent>().ActionMappings, Contains.Key("Jump"));
}
public void SaveToStreamAndLoadFromStream_AssetData_WithJsonContent()
{
// Arrange
var assetData = AssetData.CreateWithJsonContent(_assetId, _assetType, _jsonContent);
// Act
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var actual = AssetData.Load(memoryStream);
// Assert
Assert.That(actual.AssetId, Is.EqualTo(_assetId));
Assert.That(actual.AssetType, Is.EqualTo(_assetType));
Assert.That(assetData.ContentFormat, Is.EqualTo(AssetData.AssetContentFormat.Json));
var actualJsonContent = actual.ReadJsonContent <JsonContent>();
Assert.That(actualJsonContent.IntProperty, Is.EqualTo(_jsonContent.IntProperty));
Assert.That(actualJsonContent.DoubleProperty, Is.EqualTo(_jsonContent.DoubleProperty));
Assert.That(actualJsonContent.StringProperty, Is.EqualTo(_jsonContent.StringProperty));
}
public void DeleteInclude(string path)
{
AssetData data = GetTargetPath(includeList, path);
if (data != null)
{
includeList.Remove(data);
size -= GetFileSize(path);
}
UpdateReference();
AssetData mainData = GetTargetPath(includeList, mainAsset.path);
if (mainData == null)
{
mainAsset = mainData;
}
else
{
mainAsset = null;
}
}
protected void LoadDependencies(string abname)
{
string[] dependencies = mManifest.GetAllDependencies(abname);
if (dependencies.Length == 0)
{
return;
}
for (int i = 0; i < dependencies.Length; i++)
{
AssetData asset = null;
if (mAssetCache.TryGetValue(dependencies[i], out asset))
{
asset.reference++;
}
else
{
LoadRawAssetBundle(dependencies[i]);
}
}
}
public void IdTrimmer_21()
{
var ad = new AssetData();
ad.CalculateIdTrimmer(new MockTransPair[]
{
new MockTransPair {
Serial = 1, Id = "1"
},
new MockTransPair {
Serial = 2, Id = "10"
},
new MockTransPair {
Serial = 0, Id = "100"
},
new MockTransPair {
Serial = 4, Id = "20"
},
});
ad.IdTrimChars.Is(2);
}
public void SaveToFileAndLoadFromFile_AssetData_WithJsonContent()
{
// Arrange
var assetData = AssetData.CreateWithJsonContent(_assetId, _assetType, _jsonContent);
// Act
var filePath = _temporaryDirectory.GetRandomFilePath();
assetData.Save(filePath);
var actual = AssetData.Load(filePath);
// Assert
Assert.That(actual.AssetId, Is.EqualTo(_assetId));
Assert.That(actual.AssetType, Is.EqualTo(_assetType));
Assert.That(assetData.ContentFormat, Is.EqualTo(AssetData.AssetContentFormat.Json));
var actualJsonContent = actual.ReadJsonContent <JsonContent>();
Assert.That(actualJsonContent.IntProperty, Is.EqualTo(_jsonContent.IntProperty));
Assert.That(actualJsonContent.DoubleProperty, Is.EqualTo(_jsonContent.DoubleProperty));
Assert.That(actualJsonContent.StringProperty, Is.EqualTo(_jsonContent.StringProperty));
}
override public AssetData LoadAsync(string url_, CALLBACK_1 onComplete_, object refer_)
{
url_ = url_.ToLower();
AssetData data = CreateData(url_); //先创建data, 用以记录生命周期等
data.Retain(refer_);
//if (m_url2req.ContainsKey(url_))
//{
// //加载中
// if (onComplete_ != null)
// Attach(url_, onComplete_, refer_);
// return data;
//}
if (data.asset != null)
{
//加载完成
if (onComplete_ != null)
{
onComplete_(data);
}
return(data);
}
//未启动加载, 至少保持一个引用
data.Retain(this);
if (onComplete_ != null)
{
Attach(url_, onComplete_, refer_);
}
//CCApp.StartCoroutine(__LoadAsync(url_));
return(data);
}
public void TestAssetUpdateRetry()
{
var data = new AssetData { Name = "testData" };
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 2, data);
dataContextMock.Setup((ctxt) => ctxt.AttachTo("Assets", data));
dataContextMock.Setup((ctxt) => ctxt.UpdateObject(data));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
data.SetMediaContext(_mediaContext);
data.Update();
dataContextMock.Verify((ctxt) => ctxt.SaveChangesAsync(data), Times.Exactly(2));
}
public void TestAssetGetContentKeysRetry()
{
var data = new AssetData { Name = "testData", Id = "testId" };
var dataContextMock = TestMediaServicesClassFactory.CreateLoadPropertyMockConnectionClosed(2, data);
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
data.SetMediaContext(_mediaContext);
var keys = ((IAsset)data).ContentKeys;
dataContextMock.Verify((ctxt) => ctxt.LoadProperty(data, "ContentKeys"), Times.Exactly(2));
}
public void TestAssetCreateRetry()
{
var expected = new AssetData { Name = "testData" };
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 2, expected);
dataContextMock.Setup((ctxt) => ctxt.AddObject("Assets", It.IsAny<object>()));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
IAsset asset = _mediaContext.Assets.Create("Empty", "some storage", AssetCreationOptions.None);
Assert.AreEqual(expected.Name, asset.Name);
dataContextMock.Verify((ctxt) => ctxt.SaveChangesAsync(It.IsAny<object>()), Times.Exactly(2));
}
public void TestAssetCreateFailedRetryMessageLengthLimitExceeded()
{
var expected = new AssetData { Name = "testData" };
var fakeException = new WebException("test", WebExceptionStatus.MessageLengthLimitExceeded);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 10, expected);
dataContextMock.Setup((ctxt) => ctxt.AddObject("Assets", It.IsAny<object>()));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
try
{
IAsset asset = _mediaContext.Assets.Create("Empty", "some storage", AssetCreationOptions.None);
}
catch (WebException x)
{
dataContextMock.Verify((ctxt) => ctxt.SaveChangesAsync(It.IsAny<object>()), Times.Exactly(1));
Assert.AreEqual(fakeException, x);
throw;
}
Assert.Fail("Expected exception");
}
public void AddAsset(AssetData asset)
{
asset.Num = assets.Count;
assets.Add(asset);
}
public static bool ParseAssetBundleData(string configString, out AssetBundleData assetBundleData)
{
assetBundleData = null;
XmlDocument doc = new XmlDocument();
try
{
doc.LoadXml(configString);
}
catch (System.Exception exception)
{
Debug.LogError("Cannot parse config file");
return false;
}
assetBundleData = new AssetBundleData();
XmlNode buildAssetBundleNode = doc.SelectSingleNode("buildAssetBundle");
if (buildAssetBundleNode == null)
{
Debug.LogError("Cannot parse node（buildAssetBundle）");
return false;
}
// ignoreExtention
XmlNode ignoreExtentionNode = buildAssetBundleNode.Attributes.GetNamedItem("ignoreExtention");
if (ignoreExtentionNode != null)
{
string[] blocks = ignoreExtentionNode.Value.Split(';');
if (blocks != null && blocks.Length > 0)
{
assetBundleData.ignoreExtentionList = new List<string>();
foreach (string block in blocks)
{
assetBundleData.ignoreExtentionList.Add(block);
}
}
}
// platform
#if UNITY_EDITOR
XmlNode platformNode = buildAssetBundleNode.Attributes.GetNamedItem("platform");
if (platformNode != null)
{
try
{
assetBundleData.platform = (BuildTarget)System.Enum.Parse(typeof(BuildTarget), platformNode.Value);
}
catch (System.Exception exception)
{
Debug.LogError("Cannot parse node（platform）" + ":" + platformNode.Value);
return false;
}
}
#endif
// saveRoot
XmlNode saveRootNode = doc.SelectSingleNode("buildAssetBundle/saveRoot");
if (saveRootNode == null)
{
Debug.LogError("Cannot parse node（saveRoot）");
return false;
}
assetBundleData.saveRoot = saveRootNode.InnerText;
// asset
XmlNodeList assetNodeList = doc.SelectNodes("buildAssetBundle/asset");
if (assetNodeList == null || assetNodeList.Count == 0)
{
Debug.LogError("Nothing asset");
return false;
}
assetBundleData.assetDataMap = new Dictionary<string, AssetData>();
foreach (XmlNode assetNode in assetNodeList)
{
AssetData assetData = new AssetData();
assetData.enabled = true;
assetData.itemDataCollectionList = new List<ItemDataCollection>();
// id
XmlNode idNode = assetNode.Attributes.GetNamedItem("id");
if (idNode == null)
{
Debug.LogError("Missing asset id");
return false;
}
if (assetBundleData.assetDataMap.ContainsKey(idNode.Value))
{
Debug.LogError("Repeated id:" + idNode.Value);
return false;
}
if (string.IsNullOrEmpty(idNode.Value))
{
Debug.LogError("Missing asset id:" + idNode.Value);
return false;
}
assetData.id = idNode.Value;
assetBundleData.assetDataMap.Add(assetData.id, assetData);
// dependence
XmlNode dependenceNode = assetNode.Attributes.GetNamedItem("dependence");
if (dependenceNode != null)
{
assetData.dependence = dependenceNode.Value;
}
// item
XmlNodeList itemNodeList = assetNode.SelectNodes("item");
if (itemNodeList != null && itemNodeList.Count > 0)
{
foreach (XmlNode itemNode in itemNodeList)
{
ItemDataCollection itemDataCollection = new ItemDataCollection();
assetData.itemDataCollectionList.Add(itemDataCollection);
itemDataCollection.bind = false;
itemDataCollection.itemDataList = new List<ItemData>();
ItemData itemData = null;
if (!ParseItemNode(itemNode, assetData.id, out itemData))
{
return false;
}
itemDataCollection.itemDataList.Add(itemData);
}
}
// bind
XmlNodeList bindNodeList = assetNode.SelectNodes("bind");
if (bindNodeList != null)
{
foreach (XmlNode bindNode in bindNodeList)
{
ItemDataCollection itemDataCollection = new ItemDataCollection();
assetData.itemDataCollectionList.Add(itemDataCollection);
itemDataCollection.bind = true;
itemDataCollection.itemDataList = new List<ItemData>();
// savePath
XmlNode savePathNode = bindNode.Attributes.GetNamedItem("savePath");
if (savePathNode == null)
{
Debug.LogError("Cannot parse node（bind.savePath）" + ":" + assetData.id);
return false;
}
itemDataCollection.savePath = savePathNode.Value;
// item
XmlNodeList itemNodeList2 = bindNode.SelectNodes("item");
if (itemNodeList2 != null && itemNodeList2.Count > 0)
{
foreach (XmlNode itemNode in itemNodeList2)
{
ItemData itemData = null;
if (!ParseItemNode(itemNode, assetData.id, out itemData))
{
return false;
}
itemDataCollection.itemDataList.Add(itemData);
}
}
// empty test
if (itemDataCollection.IsEmpty())
{
Debug.LogWarning("Empty asset config:" + assetData.id);
}
}
}
// empty test
if (assetData.IsEmpty())
{
Debug.LogWarning("Empty asset config:" + assetData.id);
}
}
return true;
}
public void TestAssetFileUpdateRetry()
{
var dataContextMock = new Mock<IMediaDataServiceContext>();
int exceptionCount = 2;
var asset = new AssetData { Name = "testData"};
var file = new AssetFileData { Name = "testData"};
var fakeResponse = new TestMediaDataServiceResponse { AsyncState = file };
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
dataContextMock.Setup((ctxt) => ctxt.AttachTo("Files", file));
dataContextMock.Setup((ctxt) => ctxt.UpdateObject(file));
dataContextMock.Setup((ctxt) => ctxt
.SaveChangesAsync(file))
.Returns(() => Task.Factory.StartNew<IMediaDataServiceResponse>(() =>
{
if (--exceptionCount > 0) throw fakeException;
return fakeResponse;
}));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
file.SetMediaContext(_mediaContext);
SetFileAsset(file, asset);
file.Update();
Assert.AreEqual(0, exceptionCount);
}
public void AddAsset(AssetData asset, Bitmap bitmap = null)
{
cla.AddAsset(asset);
ListViewItem item = null;
if (asset.Type() == AssetClass.TEXT)
{
item = new ListViewItem(asset.AssetName, 1);
item.Group = textGroup;
item.Tag = asset;
}
else if (asset.Type() == AssetClass.TEXTURE)
{
int imageIndex = 0;
if (bitmap != null)
{
imageIndex = imageList.Images.Count;
}
imageList.Images.Add(bitmap);
item = new ListViewItem(asset.AssetName, imageIndex);
item.Group = textureGroup;
item.Tag = asset;
}
assetListView.Items.Add(item);
MarkDirty();
}
public bool TryGetDependenceList(string assetId, out AssetData[] assetDataDependenceList)
{
List<AssetData> temp = null;
AssetData assetData = null;
if (assetDataMap.TryGetValue(assetId, out assetData))
{
temp = new List<AssetData>();
while (assetData != null)
{
temp.Add(assetData);
if (assetData.HasDependence())
{
assetDataMap.TryGetValue(assetData.dependence, out assetData);
}
else
{
assetData = null;
}
}
}
if (temp != null)
{
temp.Reverse();
}
assetDataDependenceList = temp == null ? null : temp.ToArray();
return temp != null && temp.Count > 0;
}
public bool TryGetDependenceChildren(string assetId, out AssetData[] assetDataDependenceChildren)
{
List<AssetData> temp = null;
foreach (AssetData assetData in assetDataMap.Values)
{
if (assetData.id != assetId && assetData.HasDependence() && assetData.dependence == assetId)
{
if (temp == null)
{
temp = new List<AssetData>();
}
temp.Add(assetData);
}
}
assetDataDependenceChildren = temp == null ? null : temp.ToArray();
return temp != null && temp.Count > 0;
}
public void RemoveAsset(AssetData assetData)
{
if (assetData != null)
{
assets.Remove(assetData);
}
}
public static AssetData GetInstance()
{
if (instance == null)
instance = new AssetData();
return instance;
}
void EditAsset(AssetData asset)
{
if (asset != null)
{
if (asset.Type() == AssetClass.TEXT)
{
form_textEdit form = new form_textEdit((TextAsset)asset);
form.ShowDialog();
form.Dispose();
if (form.assetChanged)
{
program.MarkDirty();
}
}
else if (asset.Type() == AssetClass.TEXTURE)
{
TextureEdit form = new TextureEdit((TextureAsset)asset);
form.ShowDialog();
form.Dispose();
if (form.assetChanged)
{
program.MarkDirty();
}
}
}
}
public void TestAssetCreateFailedRetryMessageLengthLimitExceeded()
{
var dataContextMock = new Mock<IMediaDataServiceContext>();
dataContextMock.Setup((ctxt) => ctxt.AddObject("Assets", It.IsAny<object>()));
int exceptionCount = 10;
var expected = new AssetData { Name = "testData" };
var fakeResponse = new TestMediaDataServiceResponse { AsyncState = expected };
var fakeException = new WebException("test", WebExceptionStatus.MessageLengthLimitExceeded);
dataContextMock.Setup((ctxt) => ctxt
.SaveChangesAsync(It.IsAny<object>()))
.Returns(() => Task.Factory.StartNew<IMediaDataServiceResponse>(() =>
{
if (--exceptionCount > 0) throw fakeException;
return fakeResponse;
}));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
try
{
IAsset asset = _mediaContext.Assets.Create("Empty", AssetCreationOptions.None);
}
catch (WebException x)
{
Assert.AreEqual(9, exceptionCount);
Assert.AreEqual(fakeException, x);
throw;
}
Assert.Fail("Expected exception");
}
public void TestAssetFileCreateRetry()
{
var dataContextMock = new Mock<IMediaDataServiceContext>();
int exceptionCount = 2;
var expected = new AssetFileData { Name = "testData" };
var fakeResponse = new TestMediaDataServiceResponse { AsyncState = expected };
var fakeException = new WebException("testException", WebExceptionStatus.ConnectionClosed);
dataContextMock.Setup((ctxt) => ctxt.AddObject("Files", It.IsAny<object>()));
dataContextMock.Setup((ctxt) => ctxt
.SaveChangesAsync(It.IsAny<object>()))
.Returns(() => Task.Factory.StartNew<IMediaDataServiceResponse>(() =>
{
if (--exceptionCount > 0) throw fakeException;
return fakeResponse;
}));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
var asset = new AssetData { Name = "testData" };
asset.SetMediaContext(_mediaContext);
IAssetFile file = ((IAsset)asset).AssetFiles.Create("test");
Assert.AreEqual(expected.Name, file.Name);
Assert.AreEqual(0, exceptionCount);
}
private static async Task AddCompressionFilter(IOwinRequest request, IOwinResponse response, AssetData data)
{
// load encodings from header
QValueList encodings = new QValueList(request.Headers["Accept-Encoding"]);
// get the types we can handle, can be accepted and
// in the defined client preference
QValue preferred = encodings.FindPreferred("gzip", "deflate", "identity");
// if none of the preferred values were found, but the
// client can accept wildcard encodings, we'll default
// to Gzip.
if (preferred.IsEmpty && encodings.AcceptWildcard && encodings.Find("gzip").IsEmpty)
{
preferred = new QValue("gzip");
}
// handle the preferred encoding
switch (preferred.Name)
{
case "deflate":
response.ContentLength = data.DeflateData.Length;
response.Headers.Add("Content-Encoding", new[] { "deflate" });
await response.WriteAsync(data.DeflateData).ConfigureAwait(false);
break;
case "gzip":
response.ContentLength = data.ZipData.Length;
response.Headers.Add("Content-Encoding", new[] { "gzip" });
await response.WriteAsync(data.ZipData).ConfigureAwait(false);
break;
default:
response.ContentLength = data.Data.Length;
await response.WriteAsync(data.Data).ConfigureAwait(false);
break;
}
}
protected void Page_Load(object sender, System.EventArgs e)
{
Ektron.Cms.ContentAPI content_api = new Ektron.Cms.ContentAPI();
try
{
Ektron.Cms.ContentData content_data = null;
long asset_id = 0;
bool valid_attempt = false;
int LangbackUp = 0;
if (! (Request.QueryString["id"] == null))
{
asset_id = Convert.ToInt64(Request.QueryString["id"]);
}
LangbackUp = content_api.ContentLanguage;
if (Request.QueryString["LangType"] != null && content_api.ContentLanguage == -1)
{
content_api.ContentLanguage = Convert.ToInt32(Request.QueryString["LangType"]);
}
if (content_api.ContentLanguage == -1)
{
content_api.ContentLanguage = int.Parse(content_api.GetCookieValue("SiteLanguage"));
}
long iTmpCaller = content_api.RequestInformationRef.CallerId;
if (asset_id > 0)
{
content_api.RequestInformationRef.CallerId = Ektron.Cms.Common.EkConstants.InternalAdmin;
content_api.RequestInformationRef.UserId = Ektron.Cms.Common.EkConstants.InternalAdmin;
try
{
content_data = content_api.GetContentById(asset_id, 0);
}
catch
{
}
finally
{
content_api.RequestInformationRef.CallerId = iTmpCaller;
content_api.RequestInformationRef.UserId = iTmpCaller;
}
if (content_data != null)
{
content_api.ContentLanguage = content_data.LanguageId;
content_data = null;
}
content_data = content_api.ShowContentById(asset_id, content_api.CmsPreview, System.Convert.ToBoolean(! content_api.CmsPreview));
content_api.ContentLanguage = LangbackUp;
}
if ((content_data != null) && (content_data.AssetData != null) && (content_data.AssetData.Version.Length > 0))
{
string filepath = Page.Server.MapPath((string) (content_api.EkContentRef.GetViewUrl(Convert.ToInt32(content_data.Type), content_data.AssetData.Id).Replace(Page.Request.Url.Scheme + "://" + Page.Request.Url.Authority, "").Replace(":443", "").Replace(":80", "")));
if (filepath != null)
{
if (File.Exists(filepath))
{
valid_attempt = true;
string filename = Path.GetFileName(filepath);
string ext = "";
ext = Path.GetExtension(filepath);
AssetData _assetData = new AssetData();
_assetData.AssetDataFromAssetID(content_data.AssetData.Id);
if (ext.Contains("pdf") || ext.Contains("pps"))
{
WebClient client = new WebClient();
byte[] Buffer = client.DownloadData(Convert.ToString(filepath));
if (Buffer.Length > 0)
{
valid_attempt = true;
Response.Clear();
Response.ContentType = (string) ((ext.Contains("pdf")) ? "application/pdf" : "application/vnd.ms-powerpoint");
Response.AddHeader("Content-Disposition", "attachment; filename=\"" + (Request.Browser.Browser == "IE" ? (Server.UrlPathEncode(System.IO.Path.GetFileNameWithoutExtension(_assetData.Handle))) : (System.IO.Path.GetFileNameWithoutExtension(_assetData.Handle))) + ext + "\"");
Response.AddHeader("Content-Length", Buffer.Length.ToString());
Response.BinaryWrite(Buffer);
}
}
else
{
//if (ext.Contains("txt") || ext.Contains("nxb"))
//{
// filepath = DocumentManagerData.Instance.StorageLocation + _assetData.Storage + ConfigManager.pathChar + _assetData.Name;
//}
Response.Clear();
Response.ContentType = content_data.AssetData.MimeType;
Response.AddHeader("Content-Disposition", "attachment; filename=\"" + (Request.Browser.Browser == "IE" ? (Server.UrlPathEncode(_assetData.Handle)) : _assetData.Handle) + "\"");
try
{
FileInfo fi = new FileInfo(filepath);
Response.AddHeader("Content-Length", fi.Length.ToString());
}
catch { }
Response.WriteFile(filepath);
}
Response.Flush();
try
{
Response.End();
}
catch
{
}
}
}
}
if (! valid_attempt)
{
notification_message.Text = "File does not exist or you do not have permission to view this file";
notification_message.ToolTip = "Error Message - " + notification_message.Text;
// Register CSS
Ektron.Cms.API.Css.RegisterCss(this, Ektron.Cms.API.Css.ManagedStyleSheet.EktronWorkareaCss);
Ektron.Cms.API.Css.RegisterCss(this, Ektron.Cms.API.Css.ManagedStyleSheet.EktronWorkareaIeCss, Ektron.Cms.API.Css.BrowserTarget.AllIE);
Login.Visible = System.Convert.ToBoolean(!content_api.IsLoggedIn);
content_api.RequestInformationRef.RedirectFromLoginKeyName = Request.Url.PathAndQuery.ToString();
Login.RedirectFromLoginPage();
Login.Fill();
}
}
catch (Exception)
{
notification_message.Text = "File does not exist or you do not have permission to view this file";
// Register CSS
Ektron.Cms.API.Css.RegisterCss(this, Ektron.Cms.API.Css.ManagedStyleSheet.EktronWorkareaCss);
Ektron.Cms.API.Css.RegisterCss(this, Ektron.Cms.API.Css.ManagedStyleSheet.EktronWorkareaIeCss, Ektron.Cms.API.Css.BrowserTarget.AllIE);
Login.Visible = System.Convert.ToBoolean(!content_api.IsLoggedIn);
content_api.RequestInformationRef.RedirectFromLoginKeyName = Request.Url.PathAndQuery.ToString();
Login.RedirectFromLoginPage();
Login.Fill();
}
}
void Load(string fullPath)
{
assetdataList.Clear();
var filePaths = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories)
.Where(item => Path.GetExtension(item) != ".meta")
.Select(item => item.Replace(fullPath, "Assets"));
foreach( var filePath in filePaths ){
var fileGuid = AssetDatabase.AssetPathToGUID(filePath);
if( fileGuid == null ){
continue;
}
var data = new AssetData(){
isRequestAssets = true,
path = filePath,
guid = fileGuid
};
assetdataList.Add(data);
}
}
