public async Task <IActionResult> GetContents(string name, [FromQuery] bool nonPublished = false, [FromQuery] bool hidden = false)
{
var schemaEntity = await schemas.FindSchemaByNameAsync(AppId, name);
if (schemaEntity == null)
{
return(NotFound());
}
var query = Request.QueryString.ToString();
var taskForContents = contentRepository.QueryAsync(schemaEntity.Id, nonPublished, query, App);
var taskForCount = contentRepository.CountAsync(schemaEntity.Id, nonPublished, query, App);
await Task.WhenAll(taskForContents, taskForCount);
var response = new AssetsDto
{
Total = taskForCount.Result,
Items = taskForContents.Result.Take(200).Select(x =>
{
var itemModel = SimpleMapper.Map(x, new ContentDto());
if (x.Data != null)
{
itemModel.Data = x.Data.ToApiModel(schemaEntity.Schema, App.LanguagesConfig);
}
return(itemModel);
}).ToArray()
};
return(Ok(response));
}
public AssetsDto CreateAssetData(AssetsViewModel assetData)
{
AssetsDto newassetdto = new AssetsDto
{
AssetID = assetData.AssetID,
Asset_Company = assetData.Asset_Company,
Asset_Contract = assetData.Asset_Contract,
IMEI = assetData.IMEI,
SerialNo = assetData.SerialNo,
SIMNo = assetData.SIMNo,
SPMD = assetData.SPMD,
FirstCommissionDate = assetData.FirstCommissionDate,
LastCommissionDate = assetData.LastCommissionDate,
BuyBackPrice = assetData.BuyBackPrice,
PurchaseOrderNo = assetData.PurchaseOrderNo,
PurchaseDate = assetData.PurchaseDate,
Condition = assetData.Condition,
AquisitionDate = assetData.AquisitionDate,
Asset_EndUser = assetData.Asset_EndUser,
Asset_InventoryItem = assetData.Asset_InventoryItem,
Asset_LifecycleStatus = assetData.Asset_LifecycleStatus,
Asset_OSVersion = assetData.Asset_OSVersion,
CreatedBy = assetData.CreatedBy
};
return(newassetdto);
}
public async Task <IActionResult> GetAssets(string app, [FromQuery] string ids = null)
{
HashSet <Guid> idsList = null;
if (!string.IsNullOrWhiteSpace(ids))
{
idsList = new HashSet <Guid>();
foreach (var id in ids.Split(','))
{
if (Guid.TryParse(id, out var guid))
{
idsList.Add(guid);
}
}
}
var assets =
idsList?.Count > 0 ?
await assetRepository.QueryAsync(App.Id, idsList) :
await assetRepository.QueryAsync(App.Id, Request.QueryString.ToString());
var response = new AssetsDto
{
Total = assets.Total,
Items = assets.Select(x => SimpleMapper.Map(x, new AssetDto {
FileType = x.FileName.FileType()
})).ToArray()
};
Response.Headers["Surrogate-Key"] = string.Join(" ", response.Items.Select(x => x.Id));
return(Ok(response));
}
public async Task <IActionResult> GetAssetsPost(string app, [FromBody] QueryDto query)
{
var assets = await assetQuery.QueryAsync(Context, query?.ParentId, query?.ToQuery() ?? Q.Empty, HttpContext.RequestAborted);
var response = Deferred.Response(() =>
{
return(AssetsDto.FromAssets(assets, Resources));
});
return(Ok(response));
}
public async Task <IActionResult> GetAssets(string app, [FromQuery] DomainId?parentId, [FromQuery] string?ids = null, [FromQuery] string?q = null)
{
var assets = await assetQuery.QueryAsync(Context, parentId, CreateQuery(ids, q), HttpContext.RequestAborted);
var response = Deferred.Response(() =>
{
return(AssetsDto.FromAssets(assets, Resources));
});
return(Ok(response));
}
public IActionResult CreateNewAsset([FromBody] AssetsViewModel asset)
{
ReturnModel returnmessage = new ReturnModel();
AssetsDto assetaddData = CreateAssetData(asset);
bool IsrequestCreated = _Iassets.AddNewAsset(assetaddData);
returnmessage.Message = "New Asset Created";
var returnvalue = JsonConvert.SerializeObject(returnmessage);
return(Ok(returnvalue));
}
public async Task <IActionResult> GetAssets(string app, [FromQuery] Guid?parentId, [FromQuery] string?ids = null, [FromQuery] string?q = null)
{
var assets = await assetQuery.QueryAsync(Context, parentId, CreateQuery(ids, q));
var response = Deferred.Response(() =>
{
return(AssetsDto.FromAssets(assets, this, app));
});
return(Ok(response));
}
public async Task <IActionResult> GetAssets(string app, [FromQuery] string ids = null)
{
var context = Context();
var assets = await assetQuery.QueryAsync(context, Query.Empty.WithODataQuery(Request.QueryString.ToString()).WithIds(ids));
var response = AssetsDto.FromAssets(assets);
Response.Headers["Surrogate-Key"] = string.Join(" ", response.Items.Select(x => x.Id));
return(Ok(response));
}
public async Task <IActionResult> GetAssets(string app, [FromQuery] Guid?parentId, [FromQuery] string?ids = null, [FromQuery] string?q = null)
{
var assets = await assetQuery.QueryAsync(Context, parentId,
Q.Empty
.WithIds(ids)
.WithJsonQuery(q)
.WithODataQuery(Request.QueryString.ToString()));
var response = Deferred.Response(() =>
{
return(AssetsDto.FromAssets(assets, this, app));
});
return(Ok(response));
}
public async Task <IActionResult> GetAssets(string app, [FromQuery] string ids = null)
{
var context = Context();
var assets = await assetQuery.QueryAsync(context, Q.Empty.WithODataQuery(Request.QueryString.ToString()).WithIds(ids));
var response = AssetsDto.FromAssets(assets);
if (controllerOptions.Value.EnableSurrogateKeys && response.Items.Length <= controllerOptions.Value.MaxItemsForSurrogateKeys)
{
Response.Headers["Surrogate-Key"] = response.Items.ToSurrogateKeys();
}
Response.Headers["ETag"] = response.Items.ToManyEtag(response.Total);
return(Ok(response));
}
public async Task <IActionResult> GetAssets(string app, [FromQuery] string ids = null)
{
var assets = await assetQuery.QueryAsync(Context, Q.Empty.WithODataQuery(Request.QueryString.ToString()).WithIds(ids));
var response = Deferred.Response(() =>
{
return(AssetsDto.FromAssets(assets, this, app));
});
if (controllerOptions.EnableSurrogateKeys && assets.Count <= controllerOptions.MaxItemsForSurrogateKeys)
{
Response.Headers["Surrogate-Key"] = assets.ToSurrogateKeys();
}
Response.Headers[HeaderNames.ETag] = assets.ToEtag();
return(Ok(response));
}
public async Task <IActionResult> GetContents(string name, [FromQuery] string ids = null)
{
var schemaEntity = await FindSchemaAsync(name);
var idsList = new HashSet <Guid>();
if (!string.IsNullOrWhiteSpace(ids))
{
foreach (var id in ids.Split(','))
{
if (Guid.TryParse(id, out var guid))
{
idsList.Add(guid);
}
}
}
var isFrontendClient = User.IsFrontendClient();
var query = Request.QueryString.ToString();
var taskForItems = contentRepository.QueryAsync(App, schemaEntity.Id, isFrontendClient, idsList, query);
var taskForCount = contentRepository.CountAsync(App, schemaEntity.Id, isFrontendClient, idsList, query);
await Task.WhenAll(taskForItems, taskForCount);
var response = new AssetsDto
{
Total = taskForCount.Result,
Items = taskForItems.Result.Take(200).Select(x =>
{
var itemModel = SimpleMapper.Map(x, new ContentDto());
if (x.Data != null)
{
itemModel.Data = x.Data.ToApiModel(schemaEntity.Schema, App.LanguagesConfig, null, !isFrontendClient);
}
return(itemModel);
}).ToArray()
};
return(Ok(response));
}
public bool AddNewAsset(AssetsDto asset)
{
try
{
var assetExist = _context.Assets.Where(x => x.AssetID == asset.AssetID).FirstOrDefault();
if (assetExist != null)
{
return(false);
}
Assets newAsset = new Assets
{
AssetID = asset.AssetID,
Asset_Company = asset.Asset_Company,
Asset_Contract = asset.Asset_Contract,
IMEI = asset.IMEI,
SerialNo = asset.SerialNo,
SIMNo = asset.SIMNo,
SPMD = asset.SPMD,
FirstCommissionDate = asset.FirstCommissionDate,
LastCommissionDate = asset.LastCommissionDate,
BuyBackPrice = asset.BuyBackPrice,
PurchaseOrderNo = asset.PurchaseOrderNo,
PurchaseDate = asset.PurchaseDate,
Condition = asset.Condition,
AquisitionDate = asset.AquisitionDate,
Asset_EndUser = asset.Asset_EndUser,
Asset_InventoryItem = asset.Asset_InventoryItem,
Asset_LifecycleStatus = asset.Asset_LifecycleStatus,
Asset_OSVersion = asset.Asset_OSVersion,
CreatedBy = asset.CreatedBy,
Created = DateTime.Now
};
_context.Assets.Add(newAsset);
_context.SaveChanges();
}
catch (Exception Ex)
{
_WriteErrorlog.WrireErrorLogs(Ex.Message.ToString());
return(false);
}
return(true);
}
public async Task <IActionResult> GetContents(string name, [FromQuery] bool archived = false, [FromQuery] string ids = null)
{
HashSet <Guid> idsList = null;
if (!string.IsNullOrWhiteSpace(ids))
{
idsList = new HashSet <Guid>();
foreach (var id in ids.Split(','))
{
if (Guid.TryParse(id, out var guid))
{
idsList.Add(guid);
}
}
}
var isFrontendClient = User.IsFrontendClient();
var contents =
idsList != null ?
await contentQuery.QueryWithCountAsync(App, name, User, archived, idsList) :
await contentQuery.QueryWithCountAsync(App, name, User, archived, Request.QueryString.ToString());
var response = new AssetsDto
{
Total = contents.Total,
Items = contents.Items.Take(200).Select(item =>
{
var itemModel = SimpleMapper.Map(item, new ContentDto());
if (item.Data != null)
{
itemModel.Data = item.Data.ToApiModel(contents.Schema.SchemaDef, App.LanguagesConfig, !isFrontendClient);
}
return(itemModel);
}).ToArray()
};
return(Ok(response));
}
public async Task <IActionResult> GetAssets(string app, [FromQuery] string query = null, [FromQuery] string mimeTypes = null, [FromQuery] string ids = null, [FromQuery] int skip = 0, [FromQuery] int take = 10)
{
var mimeTypeList = new HashSet <string>();
if (!string.IsNullOrWhiteSpace(mimeTypes))
{
foreach (var mimeType in mimeTypes.Split(','))
{
mimeTypeList.Add(mimeType.Trim());
}
}
var idsList = new HashSet <Guid>();
if (!string.IsNullOrWhiteSpace(ids))
{
foreach (var id in ids.Split(','))
{
if (Guid.TryParse(id, out var guid))
{
idsList.Add(guid);
}
}
}
var taskForItems = assetRepository.QueryAsync(App.Id, mimeTypeList, idsList, query, take, skip);
var taskForCount = assetRepository.CountAsync(App.Id, mimeTypeList, idsList, query);
await Task.WhenAll(taskForItems, taskForCount);
var response = new AssetsDto
{
Total = taskForCount.Result,
Items = taskForItems.Result.Select(x => SimpleMapper.Map(x, new AssetDto {
FileType = x.FileName.FileType()
})).ToArray()
};
return(Ok(response));
}
