public GetItemsResponse GetItems(GetItemsRequest request)
{
GetItemsResponse viewModel = new GetItemsResponse();
try
{
var viewedItems = request.CurrentPage * request.ItemsPerPage;
// If the list isn't configurated in the settings, the application will not show it
if (!_configuration.ItemLists.ItemLists.Any(il => il.ItemTypeOriginId.Equals(request.ItemTypeOriginId)))
{
throw new Exception(string.Format("{1}{2}", _localizationErrorKey, "ListNotConfigurated"));
}
viewModel.Headers = _configuration.ItemLists.ItemLists
.Single(il => il.ItemTypeOriginId.Equals(request.ItemTypeOriginId))
.VisibleFields.Select(vf => new GetItemsResponse.Header()
{
Name = vf.Name
})
.OrderBy(vf => vf.Name)
.ToList();
viewModel.Items = _dataContext.OR_Items
.OrderByDescending(i => i.CreationDate)
.Skip(viewedItems).Take(request.ItemsPerPage)
.Where(i => i.ItemTypeOriginId.Equals(request.ItemTypeOriginId))
.Select(i => new GetItemsResponse.Item()
{
Id = i.Id,
OriginId = i.OriginId,
ItemTypeOriginId = i.ItemTypeOriginId,
CreationDate = formatDate(i.CreationDate),
LastEditDate = formatDate(i.LastEditDate),
Properties = _dataContext.OR_Properties
.Where(p => p.RelatedOriginId == i.OriginId)
.Where(p => _configuration.ItemLists.ItemLists
.Single(il => il.ItemTypeOriginId.Equals(request.ItemTypeOriginId))
.VisibleFields.Select(vf => vf.Name).ToList()
.Contains(p.Name))
.Select(p => new GetItemsResponse.Property()
{
Id = p.Id,
OriginId = p.OriginId,
Name = p.Name,
Value = p.Value
})
.OrderBy(p => p.Name)
.ToList()
})
.ToList();
}
catch (Exception exc)
{
viewModel.ResultInfo.Result = Base.ResultInfoDto.ResultEnum.Error;
viewModel.ResultInfo.ErrorMessage = exc.Message;
}
return(viewModel);
}
//#region Public Methods
//public Base AddItem(AddItemRequest request)
//{
// Base viewModel = new Base();
// try
// {
// // Prendo l'originId del tipo di item
// OR_ItemType itemType = GetItemType(request.ItemType);
// // Creo l'item
// Guid itemOriginId = Guid.NewGuid();
// OR_Item item = new OR_Item()
// {
// OriginId = itemOriginId,
// ItemTypeOriginId = itemType.OriginId,
// LastEditDate = DateTime.Now,
// CreationDate = DateTime.Now
// };
// _dataContext.OR_Items.Add(item);
// _dataContext.SaveChanges();
// // Per ogni input creo la relativa property
// foreach (AddItemRequest.Input input in request.Inputs)
// {
// Guid propertyOriginId = Guid.NewGuid();
// OR_Property property = new OR_Property()
// {
// OriginId = propertyOriginId,
// RelatedOriginId = item.OriginId,
// Name = input.Name,
// Value = input.Value
// };
// _dataContext.OR_Properties.Add(property);
// }
// // NB. Gli input vengono aggiornati automaticamente al submit
// _dataContext.SaveChanges();
// }
// catch (Exception exc)
// {
// viewModel.ResultInfo.Result = Base.ResultInfoDto.ResultEnum.Error;
// viewModel.ResultInfo.ErrorMessage = exc.Message;
// }
// return viewModel;
//}
public GetItemsResponse GetItemsToList(GetItemsRequest request)
{
GetItemsResponse viewModel = new GetItemsResponse();
try
{
var viewedItems = request.CurrentPage * request.ItemsPerPage;
// If the list isn't configurated in the settings, the application will not show it
//if (!_configuration.ItemLists.ItemLists.Any(il => il.ItemTypeOriginId.Equals(request.ItemTypeOriginId)))
//{
// throw new Exception(string.Format("{0}{1}", _localizationErrorKey, "ListNotConfigurated"));
//}
//viewModel.Headers = _configuration.ItemLists.ItemLists
// .Single(il => il.ItemTypeOriginId.Equals(request.ItemTypeOriginId))
// .VisibleFields.Select(vf => new GetItemsResponse.Header()
// {
// Name = vf.Name
// })
// .OrderBy(vf => vf.Name)
// .ToList();
viewModel.Items = _dataContext.OR_Items
.OrderByDescending(i => i.CreationDate)
.Skip(viewedItems).Take(request.ItemsPerPage)
.Where(i => i.ItemTypeOriginId.Equals(request.ItemTypeOriginId))
.Select(i => new GetItemsResponse.Item()
{
Id = i.Id,
OriginId = i.OriginId.ToString(),
ItemTypeOriginId = i.ItemTypeOriginId.ToString(),
CreationDate = FormatDate(i.CreationDate),
LastEditDate = FormatDate(i.LastEditDate),
Properties = _dataContext.OR_PropertyValues
.Where(pv => pv.ItemOriginId == i.OriginId)
.Join(_dataContext.OR_Properties,
value => value.PropertyOriginId,
property => property.OriginId,
(value, property) => new GetItemsResponse.Property()
{
Id = property.Id,
OriginId = property.OriginId.ToString(),
Name = property.Name,
Value = value.Value
})
.OrderBy(p => p.Name)
.ToList()
})
.ToList();
}
catch (Exception exc)
{
viewModel.ResultInfo.Result = Base.ResultInfoDto.ResultEnum.Error;
viewModel.ResultInfo.ErrorMessage = exc.Message;
}
return(viewModel);
}
/// <summary>
/// Get details for the items with the requested IDs.
/// </summary>
/// <param name="itemIds">List of item IDs to fetch details for.</param>
/// <returns>
/// A list of items item details and a flag to denote if the operation
/// was successful or not - in which case an error message will be included.
/// </returns>
public async Task <GetItemsResponse> GetItems(List <int> itemIds)
{
string queryString = "?" + string.Join("&", itemIds.Select(i => $"itemIds={i}"));
return(await GetCall(
$"{EnvironmentService.ServiceEndpoints[KnownService.ItemsService]}/GetByIds?{queryString}",
e => { return GetItemsResponse.CreateFailedResult(e.Message); }));
}
public GetItemsResponse GetItems()
{
GetItemsResponse response = new GetItemsResponse();
using (var client = new EchoCollectionClient())
{
response = client.GetItems();
}
return(response);
}
// TODO: consider to create a different method to use for both GetItems and GetItemTypes
// Maybe GetItemTypesForList
public GetItemsResponse GetItemTypesToList(GetItemTypesRequest request)
{
GetItemsResponse viewModel = new GetItemsResponse();
try
{
var viewedItems = request.CurrentPage * request.ItemsPerPage;
// If the list isn't configurated in the settings, the application will not show it
//if (!_configuration.ItemLists.ItemLists.Any(il => il.ItemTypeOriginId.Equals(request.ItemTypeOriginId)))
//{
// throw new Exception(string.Format("{0}{1}", _localizationErrorKey, "ListNotConfigurated"));
//}
//viewModel.Headers = _configuration.ItemLists.ItemLists
// .Single(il => il.ItemTypeOriginId.Equals(request.ItemTypeOriginId))
// .VisibleFields.Select(vf => new GetItemsResponse.Header()
// {
// Name = vf.Name
// })
// .OrderBy(vf => vf.Name)
// .ToList();
viewModel.Items = _dataContext.OR_ItemTypes
.Skip(viewedItems).Take(request.ItemsPerPage)
//.Where(i => i.ItemTypeOriginId.Equals(request.ItemTypeOriginId))
.Select(i => new GetItemsResponse.Item()
{
Id = i.Id,
OriginId = i.OriginId.ToString(),
// TODO: This m**********r don't have any properties. Just a name
Properties = new List <GetItemsResponse.Property>()
{
new GetItemsResponse.Property()
{
// TODO: avoit to set id to zero, find a better way to do it
Id = 0,
// TODO: avoit to set OriginId to string.Empty, find a better way to do it
OriginId = string.Empty,
// TODO: avoid to set the name to name, find a better way to do it
Name = "Name",
Value = i.Name
}
}
})
.ToList();
}
catch (Exception exc)
{
viewModel.ResultInfo.Result = Base.ResultInfoDto.ResultEnum.Error;
viewModel.ResultInfo.ErrorMessage = exc.Message;
}
return(viewModel);
}
public GetItemsResponse GetItems()
{
string oradb = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
OracleConnection conn = new OracleConnection(oradb);
conn.Open();
OracleCommand cmd = new OracleCommand();
cmd.Connection = conn;
cmd.CommandText = "select * from item";
cmd.CommandType = CommandType.Text;
OracleDataReader dr = cmd.ExecuteReader();
GetItemsResponse response = new GetItemsResponse();
List <Item> items = new List <Item>();
//insert into item(id, collectionid, documenttypeid, isprivate,title,createdby,datecreated,modifiedby,datemodified,isdeleted)
while (dr.HasRows && dr.Read())
{
int id = 0, collectionId, documentTypeId;
bool isPrivate;
Int32.TryParse(dr[0].ToString(), out id);
Int32.TryParse(dr[1].ToString(), out collectionId);
Int32.TryParse(dr[2].ToString(), out documentTypeId);
bool.TryParse(dr[3].ToString(), out isPrivate);
if (id == 0)
{
response.ResponseType = ResponseType.Failed;
response.Message = "Could not get Items or the list is empty";
return(response);
}
Item item = new Item
{
ID = id,
CollectionId = collectionId,
DocumentTypeId = documentTypeId,
IsPrivate = isPrivate,
Title = dr[4].ToString(),
};
items.Add(item);
}
response.Items = items;
conn.Dispose();
return(response);
}
public GetItemsResponse ApiGetItems(GetItemsRequest getItemsRequest)
{
var getItemsResponse = new GetItemsResponse();
try
{
getItemsResponse = this.ExecuteApiGetItems(getItemsRequest);
}
catch (Exception ex)
{
if (((HttpWebResponse)((WebException)ex.InnerException).Response).StatusCode == HttpStatusCode.Unauthorized)
{
_apiAuthentication.GetToken(true);
getItemsResponse = this.ExecuteApiGetItems(getItemsRequest);
}
}
return(getItemsResponse);
}
protected BasketItemsRepository CreateBasketItemsRepository(int numberOfItems)
{
var itemsService = new Mock <IItemsService>();
var itemDetails = new List <ItemDetails>();
for (int i = 0; i < numberOfItems; i++)
{
itemDetails.Add(new ItemDetails(i, $"Item {i}", 10));
}
var response = GetItemsResponse.CreateSuccessfulResult(itemDetails);
itemsService
.Setup(s => s.GetItems(It.IsAny <List <int> >()))
.ReturnsAsync(response);
return(new BasketItemsRepository(itemsService.Object));
}
public override Task <GetItemsResponse> GetItems(GetItemsRequest request, ServerCallContext context)
{
var page = _itemDao.Query(
pageIndex: request.PageIndex,
pageSize: request.PageSize,
status: request.Status,
primarySupplierId: request.PrimarySupplierId,
itemClsId: request.ItemClsId,
itemBrandId: request.ItemBrandId,
itemDepartmentId: request.ItemDepartmentId,
keyword: request.Keyword);
var response = new GetItemsResponse();
response.Items.AddRange(page.List.Select(item => _mapper.Map <ItemDTO>(item)));
response.TotalCount = page.TotalCount;
return(Task.FromResult(response));
}
public Character GetItemsFromPoE(string account, string character)
{
string url = "https://www.pathofexile.com/character-window/get-items";
string parameters = $"accountName={account}&character={character}";
string response = MakeRequest(url, parameters);
if (response == null)
{
return(null);
}
GetItemsResponse ItemsResponse = JsonConvert.DeserializeObject <GetItemsResponse>(response);
var newChar = ItemsResponse.Character;
newChar.Items = ItemsResponse.Items;
return(newChar);
}
private List <Signal> UpdateInvalidEwsIdsForRetry(List <Signal> signals, GetItemsResponse response)
{
var valuesToRetry = new List <Signal>();
// We don't know if these are 01 EWS IDs or 11.. So for all invalid IDs, we must now try to 11 to see what happens.
if (response.GetItemsErrorResults != null && response.GetItemsErrorResults.ToList().Any())
{
foreach (var value in response.GetItemsErrorResults.ToList().Where(a => a.Message == "INVALID_ID"))
{
var deviceSignal = signals.FirstOrDefault(a => a.EwsId == value.Id);
if (deviceSignal == null)
{
Logger.LogInfo(LogCategory.Processor, this.Name, $"Returned value does not exist in the list known signals..");
}
else
{
deviceSignal.EwsId = $"11{deviceSignal.DatabasePath}";
}
valuesToRetry.Add(deviceSignal);
}
}
return(valuesToRetry);
}
public IHttpActionResult GetCitations(int citStyleID)
{
string rootPath = HttpContext.Current.Server.MapPath("~") + @"CSL Library\";
string stylePath = rootPath + @"Styles\";
string itemsPath = rootPath + @"cit_items.json";
switch (citStyleID)
{
case 1:
stylePath += "ieee.csl";
break;
case 2:
stylePath += "elsevier-harvard.csl";
break;
case 3:
stylePath += "chicago-author-date.csl";
break;
case 4:
stylePath += "apa-5th-edition.csl";
break;
default:
return(BadRequest());
}
var style = CiteProc.File.Load(stylePath);
var processor = CiteProc.Processor.Compile(style);
GetItemsResponse items = new GetItemsResponse();
using (var client = new EchoCollectionClient())
{
items = client.GetItems();
}
List <CSLCompatibleItem> CSLCompatibleItems = new List <CSLCompatibleItem>(items.Items.Count);
foreach (var item in items.Items)
{
CSLCompatibleItem CslItem = new CSLCompatibleItem();
CslItem.@abstract = "bla"; // item.Metadata != null ? item.Metadata.Abstract : string.Empty;
CslItem.id = "bla"; //item.ID.ToString();
CslItem.issued = "bla"; //item.Metadata != null ? item.Metadata.Date.ToString("yyyy-MM-dd") : string.Empty;
CslItem.language = "bla"; //item.Metadata != null ? item.Metadata.Language : string.Empty;
CslItem.note = "bla"; //item.Metadata != null ? item.Metadata.Extra : string.Empty;
CslItem.publisher = "bla"; //item.Metadata != null ? item.Metadata.Publisher : string.Empty;
CslItem.title = "bla"; //item.Metadata != null ? item.Title : string.Empty;
CslItem.type = "Book";
CslItem.URL = "bla"; //item.Metadata != null ? item.Metadata.Url : string.Empty;
CslItem.author = "sss";
CSLCompatibleItems.Add(CslItem);
}
using (MemoryStream m = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(m, CSLCompatibleItems);
processor.DataProviders = CiteProc.Data.DataProvider.Load(m, CiteProc.Data.DataFormat.Json);
}
var entries = processor.GenerateBibliography();
string allEntries = "";
foreach (var entry in entries)
{
HtmlString htmlstring = new HtmlString(@"<br />");
allEntries += entry.ToHtml() + htmlstring.ToHtmlString();
}
return(Ok(allEntries));
}
public async Task Handle(GetItemsRequest request, IOutputPort <GetItemsResponse> outputPort)
{
GetItemsResponse response = await _itemRepository.GetItemsAsync(request);
outputPort.Handle(response);
}
public async Task <GetItemsResponse> GetByIds([FromQuery] List <int> itemIds)
{
return(GetItemsResponse.CreateSuccessfulResult(
_allItems.Where(i => itemIds.Contains(i.ItemId)).ToList()));
}
public async Task <GetItemsResponse> Get()
{
return(GetItemsResponse.CreateSuccessfulResult(_allItems));
}
/// <summary>
/// Get details for all items currently available.
/// </summary>
/// <returns></returns>
public async Task <GetItemsResponse> ListAllAvailabeItems()
{
return(await GetCall(
$"{EnvironmentService.ServiceEndpoints[KnownService.ItemsService]}",
e => { return GetItemsResponse.CreateFailedResult(e.Message); }));
}
