/** Attempt to extract the asset with the given filename */
public byte[] extractUsingFilename(string filename, RequestCategory requestCategory = RequestCategory.NONE)
{
if (overrideDirectory != null)
{
string bfilename = Path.GetFileName(filename);
string overriddenFilename1 = overrideDirectory + Path.DirectorySeparatorChar + bfilename;
string overriddenFilename2 = overrideDirectory + Path.DirectorySeparatorChar + Util.hashFileName(bfilename);
if (File.Exists(overriddenFilename1))
{
logger.Debug("read override file:" + filename + " => " + overriddenFilename1);
return(File.ReadAllBytes(overriddenFilename1));
}
else if (File.Exists(overriddenFilename2))
{
logger.Debug("read override file: " + filename + " => " + overriddenFilename2);
return(File.ReadAllBytes(overriddenFilename2));
}
}
byte[] data = extract(getEntryForFileName(filename, requestCategory));
if (true)
{
//File.WriteAllBytes(@"L:\RIFT_VIEW\data\" + filename, data);
}
return(data);
}
public async Task <IActionResult> Edit(int id, [Bind("id,name")] RequestCategory requestCategory)
{
if (id != requestCategory.id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(requestCategory);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RequestCategoryExists(requestCategory.id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(requestCategory));
}
private async Task <string> PrivateQuery(string url, NameValueCollection collection,
CancellationToken token = default(CancellationToken),
RequestCategory requestCategory = RequestCategory.Ignore)
{
QueryHelper.SetServicePointManagerSettings();
using (var client = new HttpClient(new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
}))
{
client.Timeout = TimeSpan.FromMilliseconds(Constant.TimeOut);
var content = new FormUrlEncodedContent(collection.AsKeyValuePair());
using (var response = await client.PostAsync(url, content, token))
{
var data = await response.Content.ReadAsStringAsync();
//Log.Info("BitSamp nonce - {0}", collection["nonce"]);
LogErrors(data, collection["nonce"]);
//FileStorageHelper.StoreFile(ExchangeName.BitStamp, url, ConvertorHelper.DictionaryToJson(collection), data, requestCategory, Log);
return(data);
}
}
}
private async Task <string> PrivateQuery(string url, Dictionary <string, string> parameters,
CancellationToken token = default(CancellationToken),
RequestCategory requestCategory = RequestCategory.Ignore)
{
QueryHelper.SetServicePointManagerSettings();
using (var client = new HttpClient(new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
}))
{
client.Timeout = TimeSpan.FromMilliseconds(Constant.TimeOut);
client.DefaultRequestHeaders.Add("Key", _key);
client.DefaultRequestHeaders.Add("Sign", Sign(ToAmPersandEncoding(parameters), _secret));
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-www-form-urlencoded"));
using (HttpResponseMessage response = await client.PostAsync(new Uri(url), new FormUrlEncodedContent(parameters), token))
{
var data = await response.Content.ReadAsStringAsync();
CorrectNonce(data, parameters);
//FileStorageHelper.StoreFile(ExchangeName.Poloniex, url, ConvertorHelper.DictionaryToJson(parameters), data, requestCategory, Log);
// Read response asynchronously
return(data);
}
}
}
public void Update(RequestCategoryDTO requestCategoryDTO)
{
var requestCategory = new RequestCategory();
requestCategory.DepartmentId = requestCategoryDTO.DepartmentId;
requestCategory.CategoryName = requestCategoryDTO.CategoryName;
_context.Entry(requestCategoryDTO).State = EntityState.Modified;
}
public void Add(RequestCategoryDTO requestCategoryDTO)
{
var requestCategory = new RequestCategory();
requestCategory.DepartmentId = requestCategoryDTO.DepartmentId;
requestCategory.CategoryName = requestCategoryDTO.CategoryName;
_context.requestCategories.Add(requestCategory);
}
public Request(string title, string description, RequestCategory category, string location)
{
Title = title;
Description = description;
Category = category;
Location = location;
CreationDate = DateTime.Now;
}
public async Task UpdateRequestAsync(RequestEditingBindingModel model)
{
Request request = await this.repository
.All()
.FirstOrDefaultAsync(r => r.Id == model.Id);
if (request == null)
{
throw new ArgumentException("Invalid request!");
}
if (model.StatusId != null && model.StatusId != request.StatusId)
{
RequestStatus status = await this.statusService.GetAll()
.FirstOrDefaultAsync(s => s.Id == model.StatusId);
if (status == null)
{
throw new ArgumentException("Invalid status!");
}
request.StatusId = status.Id;
if (status.Id == WebConstants.ClosedStatusId || status.Id == WebConstants.RejectedStatusId)
{
request.EndTime = DateTime.UtcNow;
}
}
if (model.CategoryId != null && model.CategoryId != request.CategoryId)
{
RequestCategory category = await this.categoriesService.ById(Convert.ToInt32(model.CategoryId)).FirstOrDefaultAsync();
if (category == null)
{
throw new ArgumentException("Invalid category!");
}
request.CategoryId = category.Id;
}
//if (model.AssignToId != null && model.AssignToId != request.AssignedToId)
//{
// User technician = this.userService.GetById(model.AssignToId);
// if (technician == null || technician.RoleId == WebConstants.UserRoleId)
// {
// throw new ArgumentException("Invalid technician!");
// }
// request.AssignedToId = technician.Id;
//}
if (model.Resolution != request.Resolution)
{
request.Resolution = model.Resolution;
}
await this.SaveChangesAsync();
}
private async Task <CryptsyResponse> CryptsyPrivateQuery(Dictionary <string, string> args,
CancellationToken token = default(CancellationToken),
RequestCategory requestCategory = RequestCategory.Ignore)
{
var data = await PrivateQuery(args, token);
//FileStorageHelper.StoreFile(ExchangeName.Cryptsy, _apiUri.AbsoluteUri, ConvertorHelper.DictionaryToJson(args), data, requestCategory, _log);
LastMessage = data;
return(GetCryptsyResponse(ref data));
}
public RequestCategory Add(RequestCategory requestCategory)
{
if (_requestCategoryRepository.Count(x => x.Name == requestCategory.Name) == 0)
{
return(_requestCategoryRepository.Add(requestCategory));
}
else
{
return(null);
}
}
public async Task <IActionResult> Create([Bind("id,name")] RequestCategory requestCategory)
{
if (ModelState.IsValid)
{
_context.Add(requestCategory);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(requestCategory));
}
//Request
public static void UpdateRequestCategory(this RequestCategory requestCategory, RequestCategoryViewModel requestCategoryVm)
{
requestCategory.ID = requestCategoryVm.ID;
requestCategory.Name = requestCategoryVm.Name;
requestCategory.Requests = requestCategoryVm.Requests;
requestCategory.CreatedDate = requestCategoryVm.CreatedDate;
requestCategory.CreatedBy = requestCategoryVm.CreatedBy;
requestCategory.UpdatedDate = requestCategoryVm.UpdatedDate;
requestCategory.UpdatedBy = requestCategoryVm.UpdatedBy;
requestCategory.MetaKeyword = requestCategoryVm.MetaKeyword;
requestCategory.MetaDescription = requestCategoryVm.MetaDescription;
requestCategory.Status = requestCategoryVm.Status;
}
public async Task <T> PrivateQuery <T>(string url, Dictionary <string, object> parameters,
CancellationToken token = default(CancellationToken),
RequestCategory requestCategory = RequestCategory.Ignore)
{
string resultData = string.Empty;
try
{
parameters["nonce"] = Convert.ToString(GetNonce());
resultData = await PrivateQuery(url, parameters, token);
BitFinexResponse response = null;
try
{
response = JsonConvert.DeserializeObject <BitFinexResponse>(resultData);
}
catch
{
// ignored
}
if (response != null && !response.IsSuccess)
{
// Log.Error($"RequestCategory - {requestCategory} ExchangeName - {ExchangeName.BitFinex}, Response - {resultData}");
}
//FileStorageHelper.StoreFile(ExchangeName.BitFinex, url, ConvertorHelper.DictionaryToJson(parameters), resultData, requestCategory, Log);
return(JsonConvert.DeserializeObject <T>(resultData));
}
catch (Exception ex)
{
if (resultData.Contains(NonceError))
{
parameters["nonce"] = Convert.ToString(GetNonce());
}
else
{
if (!(string.IsNullOrEmpty(resultData) && url.Contains("balances")))
{
;
}
//Log.Warn("BitFinex: Can't parse json {0} to BitFinex<{1}>, URL - {2}, Exception Message - {3}, Nonce - {4}", resultData, typeof(T), url, ex.Message, parameters["nonce"]);
}
throw;
}
}
private async Task <T> PrivateQuery <T>(string url, Dictionary <string, string> parameters,
CancellationToken token = default(CancellationToken),
RequestCategory requestCategory = RequestCategory.Ignore)
{
string resultData = String.Empty;
return(await RetryHelper.DoAsync(async() =>
{
try
{
resultData = await PrivateQuery(url, parameters, token, requestCategory);
return JsonConvert.DeserializeObject <T>(resultData);
}
catch (Exception ex)
{
//Log.Warn("Poloniex: Can't parse json {0} to Poloniex<{1}>, URL - {2}, Exception Message - {3}, Nonce - {4}", resultData, typeof(T), url, ex.Message, parameters["nonce"]);
throw;
}
}, TimeSpan.FromMilliseconds(Constant.DefaultRetryInterval)));
}
public async Task UpdateRequestAsync(int id, RequestEditingBindingModel model)
{
Request request = await this.repository.All().FirstOrDefaultAsync(r => r.Id == id);
if (model.StatusId != null && model.StatusId != request.StatusId)
{
RequestStatus status = await this.GetAllStatuses().FirstOrDefaultAsync(s => s.Id == model.StatusId);
if (status != null)
{
request.StatusId = status.Id;
}
if (status.Name.ToLower() == "closed" || status.Name.ToLower() == "rejected")
{
request.EndTime = DateTime.UtcNow;
}
}
if (model.CategoryId != null && model.CategoryId != request.CategoryId)
{
RequestCategory category = await this.categoriesService.ById(Convert.ToInt32(model.CategoryId)).FirstAsync();
if (category != null)
{
request.CategoryId = category.Id;
}
}
if (model.AssignToId != null && model.AssignToId != request.AssignedToId)
{
User technician = await this.userManager.FindByIdAsync(model.AssignToId);
if (technician != null)
{
request.AssignedToId = technician.Id;
}
}
await this.SaveChangesAsync();
}
public JsonResult AddOrUpdate(string model)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
var requestCategoryViewModel = serializer.Deserialize <RequestCategoryViewModel>(model);
RequestCategory requestCategory = new RequestCategory();
requestCategory.UpdateRequestCategory(requestCategoryViewModel);
if (requestCategory.ID == 0)
{
var newRequestCategoryService = _requestCategoryService.Add(requestCategory);
if (newRequestCategoryService == null)
{
SetAlert("error", "Loại yêu cầu đã tồn tại.");
return(Json(new
{
status = false
}));
}
else
{
_requestCategoryService.SaveChanges();
SetAlert("success", "Tạo thành công loại yêu cầu.");
return(Json(new
{
status = true
}));
}
}
else
{
_requestCategoryService.Update(requestCategory);
_requestCategoryService.SaveChanges();
SetAlert("success", "Chỉnh sửa thành công loại yêu cầu.");
return(Json(new
{
status = true
}));
}
}
private AssetEntry getEntryForFileName(string filename, RequestCategory requestCategory = RequestCategory.NONE)
{
//logger.Debug("get entry for filename:" + filename + " with request category " + requestCategory);
List <ManifestEntry> entries = Manifest.getEntriesForFilenameHash(Util.hashFileName(filename));
if (entries.Count() == 0)
{
// lets see if the filename is actually a hash (this shouldn't happen, but whatevers)
entries = Manifest.getEntriesForFilenameHash(filename);
if (entries.Count() == 0)
{
throw new Exception("Filename hash not found in manifest: '" + filename + "'");
}
logger.Warn("Using filename[" + filename + "] as hash");
}
// strip out duplicate patch paks
entries.RemoveAll(e => {
return(Manifest.getPAKName(e.pakIndex).Contains("patch") && entries.Any(x => x != e && x.idStr.Equals(e.idStr)));
});
// logger.Debug("found " + entries.Count() + " entries in manifest that match");
string id = "";
if (entries.Count() == 1)
{
// if there was only one result, then use it
id = entries.First().idStr;
}
else
{
ManifestEntry finalEntry = null;
// work out which one we want based on the category
string requestStr = requestCategory.ToString().ToLower();
//logger.Debug("multiple ids found for " + filename + ", using request category " + requestStr);
foreach (ManifestEntry entry in entries)
{
//logger.Debug("[" + filename + "]: considering entry:" + entry + " :" + manifest.getPAKName(entry.pakIndex));
ManifestPAKFileEntry pak = Manifest.getPAK(entry.pakIndex);
string pakName = pak.name;
if (pakName.Contains(requestStr))
{
finalEntry = entry;
break;
}
}
if (finalEntry == null)
{
// if we were still unable to break the tie
logger.Error("tiebreak for " + filename + " no id match");
// one final check on the language, if an english one exists, use that over any other non-english one
IEnumerable <ManifestEntry> engUni = entries.Where(e => e.lang == 0 || e.lang == 1);
// if the number of english entries is different to the number of entries, then we should choose an english one and assume it is that one
if (engUni.Count() > 0 && engUni.Count() != entries.Count())
{
logger.Debug("tie broken with english language choice: " + finalEntry + " :" + Manifest.getPAKName(finalEntry.pakIndex));
finalEntry = engUni.First();
}
else
{
// fail?
String str = "";
foreach (ManifestEntry entry in entries)
{
str += "\t" + entry + " :" + Manifest.getPAKName(entry.pakIndex) + "\n";
}
string errStr = ("Multiple ids match the filename [" + filename + "] but no request category was given, unable to determine which to return.\n" + str);
throw new Exception(errStr);
}
}
id = finalEntry.idStr;
//logger.Debug("settled on entry:" + finalEntry + " :" + manifest.getPAKName(finalEntry.pakIndex));
}
//logger.Debug("find asset file for id:" + id);
AssetFile assetFile = FindAssetFileForId(id);
//logger.Debug("result:" + assetFile);
if (assetFile == null)
{
throw new Exception(
"Filename found in manifest but unable to locate ID[" + id + "] in assets: '" + filename
+ "'");
}
//logger.Debug("found with id:" + id);
return(assetFile.getEntry(id));
}
public void DeleteRequestCategory(RequestCategory requestCategory)
{
_context.RequestCategories.Remove(requestCategory);
}
public ActionResult GetCategory(RequestCategory requestCategory)
{
var listofCategory = _menuCategory.GetCategorybyRoleId(requestCategory.RoleID);
return(Json(listofCategory, JsonRequestBehavior.AllowGet));
}
public async Task <T> Query <T>(string uri, Dictionary <string, string> args = null, bool authenticationRequired = false, CancellationToken token = default(CancellationToken), RequestCategory requestCategory = RequestCategory.Ignore)
{
var responseStr = await Query(uri, args, authenticationRequired, token);
BittrexSingleResponse <T> responseObject;
try
{
//FileStorageHelper.StoreFile(ExchangeName.Bittrex, uri, ConvertorHelper.DictionaryToJson(args), responseStr, requestCategory, Log);
responseObject = JsonConvert.DeserializeObject <BittrexSingleResponse <T> >(responseStr);
}
catch (Exception ex)
{
//Log.Warn("Bittrex: Can't parse json {0} to BittrexSingleResponse<{1}>, Message - {2}", responseStr, typeof(T), ex.Message);
throw;
}
if (!responseObject.success)
{
throw new ApplicationException("Bittrex API Exception:" + responseObject.message);
}
return(responseObject.result);
}
private async Task <JObject> QueryPrivate(string method,
string postData = null,
CancellationToken token = default(CancellationToken),
RequestCategory requestCategory = RequestCategory.Ignore)
{
KrakenResponse responseObject;
dynamic jObj;
var data = await PrivateQuery(method, postData, token);
try
{
//FileStorageHelper.StoreFile(ExchangeName.Kraken, BaseUri + string.Format("{0}/private/{1}", Version, method), postData ?? String.Empty, data, requestCategory, _log);
jObj = JObject.Parse(data);
responseObject = JsonConvert.DeserializeObject <KrakenResponse>(data);
}
catch (Exception)
{
//_log.Warn("Kraken: Can't parse json {0} to KrakenSingleResponse<{1}>", data, typeof(KrakenResponse));
throw;
}
if (responseObject.Error.Any(x => _orderErrors.Any(oerr => oerr == x)))
{
throw new KrakenInvalidOrderException("Kraken API Exception:" + responseObject.Error.First());
}
if (responseObject.Error.Any(x => x == ErrorRateLimit))
{
throw new KrakenRateLimitExceededException("Kraken API Exception:" + responseObject.Error.First());
}
if (responseObject.Error.Any(x => x == ErrorInvalidKey))
{
throw new KrakenInvalidKeyException("Kraken API Exception:" + responseObject.Error.First());
}
if (responseObject.Error.Any(x => x == TemporaryLockOut))
{
throw new KrakenTemporaryLockOutException("Kraken API Exception:" + responseObject.Error.First());
}
if (responseObject.Error.Any(x => x == ErrorInvalidNonce))
{
throw new KrakenInvalidNonceException("Kraken API Exception:" + responseObject.Error.First());
}
if (responseObject.Error.Any(x => x == ErrorInsufficientFunds))
{
throw new KrakenInsufficientFundsException("Kraken API Exception:" + responseObject.Error.First());
}
if (responseObject.Error.Any())
{
throw new ApplicationException("Kraken API Exception:" + responseObject.Error.First());
}
return(jObj.result);
}
private async Task <BterPrivateResult> PrivateQuery(string path, NameValueCollection req, string key, string secret,
CancellationToken token = default(CancellationToken), RequestCategory requestCategory = RequestCategory.Ignore)
{
QueryHelper.SetServicePointManagerSettings();
using (var client = new HttpClient(new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
}))
{
client.Timeout = TimeSpan.FromMilliseconds(Constant.TimeOut);
string reqToString = EncodeParameters(req);
client.DefaultRequestHeaders.Add("KEY", key);
client.DefaultRequestHeaders.Add("SIGN", Sign(reqToString, secret));
var content = new FormUrlEncodedContent(req.AsKeyValuePair());
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
using (var response = await client.PostAsync(_basePrivateUri.AbsoluteUri + _apiVersion + "private/" + path, content, token))
{
var data = await response.Content.ReadAsStringAsync();
try
{
// FileStorageHelper.StoreFile(ExchangeName.Bter, path, ConvertorHelper.DictionaryToJson(req), data, requestCategory, Log);
var bterResponse = JsonConvert.DeserializeObject <BterResponse>(data);
return(new BterPrivateResult
{
BterResponse = bterResponse,
JObject = JObject.Parse(data)
});
}
catch (WebException wex)
{
//Log.Error(wex);
return(new BterPrivateResult
{
BterResponse = new BterResponse(),
JObject = null
});
}
}
}
}
public void AddRequestCategory(RequestCategory requestCategory)
{
_context.RequestCategories.Add(requestCategory);
}
public void Update(RequestCategory requestCategory)
{
_requestCategoryRepository.Update(requestCategory);
}
public IPagedList <Category> Get([FromQuery] RequestCategory filter)
{
return(_categoryServices.GetAllCategories(filter.Name, filter.PageIndex, filter.PageSize));
}
