public async Task <IHttpActionResult> Get(int?pageNumber = null, bool isAscending = false, string search = null)
{
try
{
Filter.PageNumber = pageNumber ?? 1;
Filter.Search = search;
Filter.IsAscending = isAscending;
var pagedList = await VehicleMakeService.PagedList(Filter);
var newModel = new
{
Model = pagedList.ToList(),
PageNumber = pagedList.PageNumber,
PageSize = pagedList.PageSize,
TotalCount = pagedList.TotalItemCount,
isAscending = Filter.IsAscending
};
return(Ok(newModel));
}
catch (Exception ex)
{
LogError.LogError(ex);
return(BadRequest(ex.Message));
}
}
public void Visit(ProgramContext parserRule)
{
basicTypes = new BasicTypes(parserRule, globalContext);
parserRule._classes.Insert(0, basicTypes.Int);
parserRule._classes.Insert(0, basicTypes.Bool);
parserRule._classes.Insert(0, basicTypes.String);
parserRule._classes.Insert(0, basicTypes.IO);
parserRule._classes.Insert(0, basicTypes.Void);
parserRule._classes.Insert(0, basicTypes.Object);
foreach (var _class in parserRule._classes)
{
if (globalContext.IfDefineType(_class.type.Text))
{
errorLogger.LogError($"El programa ya contiene una definicion para { _class.type.Text}, linea {_class.type.Line} y la columna {_class.type.Column}");
}
else
{
globalContext.CreateChildContext(_class.type.Text);
if (_class.inherits != null)
{
_class.father = parserRule._classes.FirstOrDefault(p => p.type.Text == _class.inherits.Text);
}
else if (_class.type.Text != "Object" && _class.type.Text != "void")
{
_class.father = basicTypes.Object;
}
}
}
if (!globalContext.IfDefineType("Main"))
{
errorLogger.LogError("El programa no contiene la definicion para Main");
}
}
private FormatString ParseFormatString(int start)
{
var items = new List <FormatStringItem>();
while (true)
{
switch (nextTokenInfo.Token)
{
case '{':
try
{
items.Add(ParseFormat());
}
catch (FormattingException e)
{
foreach (Error error in e.Errors)
{
errorLogger.LogError(error);
}
scanner.State = ScannerState.ScanningText;
while (nextTokenInfo.Token != '}' && nextTokenInfo.Token != Token.EndOfInput)
{
Consume();
}
break;
}
continue;
case '}':
if (start > 0)
{
return(CreateFormatString(start, items));
}
errorLogger.LogError(nextTokenInfo.Location, "Unescaped \"}\".");
break;
case Token.EndOfInput:
return(CreateFormatString(start, items));
case Token.Text:
items.Add(new Text(nextTokenInfo.Location, nextTokenInfo.Text));
break;
default:
// this should not happen
throw new InvalidOperationException(
Utilities.InvariantFormat("Token {0} is not valid here.", Token.ToString(nextTokenInfo.Token)));
}
Consume();
}
}
private void LogError(Uri baseUrl, IRestRequest request, IRestResponse response)
{
//Get the values of parameters passed to the API
string parameters = string.Join(", ", request.Parameters.Select(x => x.Name.ToString()));
//Setup the information message with the URL, the status code, and the parameters
string info = "Request to " + BaseUrl.AbsoluteUri + request.Resource + " failed with status code " + response.StatusCode + ", parameters: "
+ parameters + ", and content: " + response.Content;
//Accquire the actual exception
Exception ex;
if (response != null && response.ErrorException != null)
{
ex = response.ErrorException;
}
else
{
ex = new Exception(info);
info = string.Empty;
}
//Log the exception and info messages
_errorLogger.LogError(ex, info);
}
public void LogTime(int hours, int minutes, string description)
{
try
{
//dobaviti podatke o trenutno logovanom korisniku (username, email)
string userName = userLogger.GetLoggedUserName();
string userEmail = userLogger.GetLoggedUserEmail(userName);
//dobaviti podatke o projektu i aktivnosti (task) na projektu za koju se loguje vreme
int taskId = taskManager.GetTaskId(userName, userEmail);
//logovati vreme - sacuvati podatke u bazi
task.TaskId = taskId;
task.Hours = hours;
task.Minutes = minutes;
task.Description = description;
bool saved = task.SaveToDB();
if (saved)
{
//poslati mejl obavestenja o logovanom vremenu
emailSender.SendEmail(userEmail,
"Time logged successfully",
hours + " hours and " + minutes + " minutes successfully logged to task with ID=" + taskId);
}
else
{
throw new Exception("Failed to save data to database");
}
}
catch (Exception ex) //obrada gresaka
{
errorLogger.LogError(ex);
throw ex;
}
}
public Dictionary <Languages, LanguageDefinitions> LoadFiles()
{
Dictionary <Languages, LanguageDefinitions> result = new Dictionary <Languages, LanguageDefinitions>();
foreach (Languages l in Enum.GetValues(typeof(Languages)))
{
string filename = GetFilename(l);
string path = Path.Combine(saveDirectory, filename);
if (File.Exists(path))
{
string contents = File.ReadAllText(path);
bool loaded = file.FromXML(contents);
if (loaded)
{
result[l] = new LanguageDefinitions(l, file.Data);
}
}
else
{
errorLogger.LogError(new Error(ErrorCode.MissingLanguageFile, ErrorSeverity.Warning, path));
}
}
return(result);
}
public async Task <HostResult> CreateAsync(string userId, CreateHostRequest request)
{
var fileLocation = _setting.ScriptLocation;
var currentHost = _db.Hosts.FirstOrDefault(c => c.HostAddress == request.HostAddress);
if (currentHost == null)
{
var hashCode = Guid.NewGuid().ToString();
var newHost = new Host()
{
HostAddress = request.HostAddress, UserId = userId, HostValidated = true, PageValidated = false, HashCode = hashCode, UserValidityId = 9, ProductValidityId = 9
};
await _db.Hosts.AddAsync(newHost);
await _db.SaveChangesAsync();
await _db.UsersHostAccess.AddAsync(new UsersHostAccess()
{
UserId = userId, AdminAccess = true, HostId = newHost.Id
});
await _db.SaveChangesAsync();
try
{
if (!System.IO.Directory.Exists(System.IO.Path.Combine(fileLocation, request.HostAddress.RemoveSpecialCharacters())))
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(fileLocation, request.HostAddress.RemoveSpecialCharacters()));
System.IO.File.Copy(System.IO.Path.Combine(fileLocation, "track.js"), System.IO.Path.Combine(fileLocation, request.HostAddress.RemoveSpecialCharacters(), "track.js"));
}
}
catch (Exception ex)
{
await _errorLogger.LogError("DashboardHostManager=>" + ex.Message);
}
return(new HostResult()
{
Id = newHost.Id, TrackerAddress = _setting.ScriptAPIUrlBase + newHost.HostAddress.RemoveSpecialCharacters() + "/track.js", HostAddress = newHost.HostAddress
});
}
else
{
return new HostResult()
{
Id = currentHost.Id,
TrackerAddress = "https://api.stickytracker.net/" + currentHost.HostAddress.RemoveSpecialCharacters() + "/track.js",
HostAddress = currentHost.HostAddress,
AlreadyExists = true,
SegmentCreationAccess = new SegmentCreationAccess()
{
Page = currentHost.HostValidated && currentHost.PageValidated,
AddToCart = currentHost.AddToCardValidated,
Buy = currentHost.FinalizeValidated,
ProductVisit = currentHost.CategoryValidated
}
}
};
}
private int ScanText()
{
do
{
char c = input[positionInInput++];
switch (c)
{
case '{':
case '}':
if (textBuilder.Length == 0)
{
textBuilder.Append(c);
return(c);
}
positionInInput--;
return(Token.Text);
case '\\':
if (positionInInput == input.Length)
{
errorLogger.LogError(
new Location(positionInInput, positionInInput), "Unexpected end of input.");
}
else if (!Utilities.MustBeEscaped(c = input[positionInInput++]))
{
errorLogger.LogError(
new Location(positionInInput - 2, positionInInput),
Utilities.InvariantFormat("\"{0}\" cannot be escaped.", c));
}
break;
}
textBuilder.Append(c);
}while(positionInInput < input.Length);
return(Token.Text);
}
public void Visit(ClassDef node)
{
currentType = Context.GetType(node.Type);
if (node.typeInherited != null)
{
IType t;
if ((t = Context.GetType(node.typeInherited)) != null)
{
currentType.TypeInherited = t;
t.ChildTypes.Add(currentType);
}
else
{
errorLog.LogError(string.Format(TYPEINHERITEDDOESNEXIST, node.Line, currentType.Name, node.typeInherited));
}
}
else
{
var obj = currentType.TypeInherited = Context.GetType("Object");
obj.ChildTypes.Add(currentType);
}
foreach (var item in node.Attributes)
{
Visit(item);
}
foreach (var item in node.Methods)
{
Visit(item);
}
currentType.DefineAttribute("self", currentType);
}
public IEnumerable <IRecord> FromString(string [] recordLines)
{
recordLines = recordLines.Where(x => !string.IsNullOrEmpty(x)).ToArray();
if (recordLines == null || recordLines.Length == 0)
{
this.logger.LogError($"No record text provided");
yield break;
}
var firstLine = recordLines.First();
bool found = false;
var delim = ' ';
foreach (var curDelimiter in allDelimiters)
{
if (firstLine.Contains(curDelimiter.ToString()))
{
delim = curDelimiter;
found = true;
break;
}
}
if (!found)
{
logger.LogError("Text did not contain expected delimiters");
yield break;
}
foreach (var curLine in recordLines)
{
Record ret = new Record();
var curSplit = curLine.Split(delim);
if (curSplit.Length != ExpectedLen)
{
continue;
}
ret.LastName = curSplit[LastNameIndex];
ret.FirstName = curSplit[FirstNameIndex];
ret.Gender = curSplit[GenderIndex];
ret.FavoriteColor = curSplit[FavColorIndex];
ret.DateOfBirth = ParseDate(curSplit[DOBIndex]);
if (ret.DateOfBirth == null)
{
yield break;
}
yield return(ret);
}
}
private object GetValue(string propertyName, object fallBack)
{
string value = null;
try
{
value = (string)Registry.GetValue(RegistryKey, propertyName, fallBack);
}
catch (Exception e)
{
Log.LogError(() => $"{nameof(RegeditReporterConfig)}.{nameof(GetValue)}({propertyName}, {fallBack}): " +
$"Call to Registry.GetValue({RegistryKey}, {propertyName}, {fallBack}) failed", e, ErrorCodes.FailedToReadRegistry);
}
return(string.IsNullOrWhiteSpace(value) ? fallBack : value);
}
private void ParseEntry(TextReader reader, int lineNumber)
{
if (!reader.TryReadExpected("STR_"))
{
_logger.LogError(lineNumber, "Expected line to start with 'STR_'");
return;
}
string identifier = reader.ReadString(4);
string[] validIdentifiers = null;
switch (_currentEntryType)
{
case LanguageEntryType.ObjectOverride:
validIdentifiers = ObjectOverrideIdentifiers;
break;
case LanguageEntryType.ScenarioOverride:
validIdentifiers = ScenarioOverrideIdentifiers;
break;
}
if (validIdentifiers == null)
{
ushort index;
if (!UInt16.TryParse(identifier, out index))
{
_logger.LogError(lineNumber, $"String identifier must be between {UInt16.MinValue} and {UInt16.MaxValue}");
return;
}
}
else
{
if (!validIdentifiers.Contains(identifier))
{
_logger.LogError(lineNumber, $"Invalid identifier '{identifier}'");
}
if (!_groupItemIdentifiers.Add(identifier))
{
_logger.LogWarning(lineNumber, $"Entry '{identifier}' already set.");
}
}
ParseWhitespace(reader, lineNumber, 4);
if (!reader.TryReadExpected(":"))
{
_logger.LogError(lineNumber, "Expected ':' after identifier");
}
string text = reader.ReadToEnd();
}
protected override object DoVisit(ArgumentIndex argumentIndex)
{
if (argumentIndex.Index >= arguments.Count)
{
errorLogger.LogError(
argumentIndex.Location, Utilities.InvariantFormat("Argument index {0} is out of range.", argumentIndex.Index));
return(Error);
}
return(arguments[argumentIndex.Index].Value);
}
public void LogError(Uri baseURL, IRestRequest request, IRestResponse response)
{
string parameters = string.Join(", ", request.Parameters.Select(x => x.Name.ToString() + "=" + ((x.Value == null) ? "NULL" : x.Value)).ToArray());
string info = "Request to " + baseURL.AbsoluteUri + request.Resource + " failed with status code " + response.StatusCode + ", parameters: " + parameters + ", and content: " + response.Content;
Exception ex;
if (response != null && response.ErrorException != null)
{
ex = response.ErrorException;
}
else
{
ex = new Exception(info);
info = String.Empty;
}
_errorLogger.LogError(ex, info);
}
protected async virtual Task ManageConsumersLoopAsync(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
var queueInfo = CreateQueueInfo();
lock (_scalingLock)
{
_scalingAmount = _consumerCountManager.GetScalingAmount(queueInfo, _consumerWorkersCount);
for (var i = 1; i <= _scalingAmount; i++)
{
Task.Factory.StartNew(async() =>
{
try
{
Interlocked.Decrement(ref _scalingAmount);
Interlocked.Increment(ref _consumerWorkersCount);
using (IQueueConsumerWorker consumerWorker = CreateNewConsumerWorker())
{
await consumerWorker.DoConsumeAsync(cancellationToken).ConfigureAwait(false);
}
}
catch (Exception exception)
{
Interlocked.Increment(ref _scalingAmount);
Interlocked.Decrement(ref _consumerWorkersCount);
_errorLogger?.LogError("RabbitMQ.AdvancedConsumer", exception.ToString(),
"QueueName", _queueName);
}
}, cancellationToken);
}
}
await Task.Delay(_consumerCountManager.AutoscaleFrequency, cancellationToken).ConfigureAwait(false);
}
}
public void PlaceOrder(int orderId)
{
try
{
//dobaviti neophodne korisnicke podatke
int userId = userLogger.GetLoggedUserId();
string userEmail = userLogger.GetUserEmail(userId);
//proveriti dostupnost proizvoda
bool productAvailable = productChecker.CheckProductAvailability(orderId);
//ukoliko su svi proizvodi dostupni skinuti proizvode sa stanja, sacuvati porudzbinu u bazi i poslati mejl potvrde
if (productAvailable)
{
stockManager.TakeOffStock(orderId); //skidanje sa lagera
order.SaveOrderToDB(orderId, userId); //cuvanje porudzbine u bazi
emailSender.SendEmail(userEmail,
"Order created successfully",
"Your order was created successfully. You can use the orderId=" + orderId + " to track your order."); //slanje mejla potvrde
}
else
{
throw new Exception("Some products are not available"); //neki proizvod nije dostupan
}
}
catch (Exception ex)
{
if (ex.Message.Equals("Some products are not available"))
{
order.RemoveFromDB(orderId); //porudzbina sa svim proizvodima se uklanja iz baze
stockManager.PutOnStock(orderId); //vracanje starog stanja na lageru
}
errorLogger.LogError(ex.Message); //logovanje greske
throw ex;
}
}
public static FunctionFormatTagParametersInfo ParseParameters(string key, IEnumerable <string> types, IEnumerable <ReswItem> basicLocalizedItems, string resourceFilename, IErrorLogger logger)
{
var result = new FunctionFormatTagParametersInfo();
var paramIndex = 1;
foreach (var type in types)
{
var matchNamedParameters = RegexNamedParameters.Match(type.Trim());
if (!matchNamedParameters.Success)
{
logger?.LogError($"[ReswPlus] Incorrect tag for the key '{key}': incorrect formatting", resourceFilename);
return(null);
}
if (matchNamedParameters.Groups["literalString"].Success)
{
var param = new LiteralStringFormatTagParameter()
{
Value = matchNamedParameters.Groups["literalString"].Value
};
result.Parameters.Add(param);
}
else
{
if (matchNamedParameters.Groups["localizationRef"].Success)
{
var localizationRef = matchNamedParameters.Groups["localizationRef"].Value;
// Localization Identifier
if (!basicLocalizedItems.Any(i => i.Key == localizationRef))
{
//Identifier not found
logger?.LogError($"ReswPlus: Incorrect tag for the key '{key}': '{localizationRef}' doesn't exist in the resw file.", resourceFilename);
return(null);
}
var param = new StringRefFormatTagParameter()
{
Id = localizationRef
};
result.Parameters.Add(param);
}
else
{
var paramTypeId = matchNamedParameters.Groups["type"].Value;
var isQuantifier = matchNamedParameters.Groups["quantifier"].Success;
var paramName = matchNamedParameters.Groups["name"].Value;
if (isQuantifier && !string.IsNullOrEmpty(paramTypeId) && string.IsNullOrEmpty(paramName))
{
if (!AcceptedTypes.ContainsKey(paramTypeId))
{
paramName = paramTypeId;
paramTypeId = "";
}
}
else if (!isQuantifier && paramTypeId == "Plural" && string.IsNullOrEmpty(paramName))
{
isQuantifier = true;
paramTypeId = paramName = "";
}
else if (!isQuantifier && MacrosAvailable.TryGetValue(paramTypeId, out var macroID) && string.IsNullOrEmpty(paramName))
{
result.Parameters.Add(new MacroFormatTagParameter()
{
Id = macroID
});
continue;
}
var paramType = GetParameterType(paramTypeId, isQuantifier);
if (!paramType.type.HasValue)
{
logger?.LogError($"ReswPlus: Incorrect tag for the key '{key}': '{paramTypeId}' is not a correct type.", resourceFilename);
return(null);
}
if (string.IsNullOrEmpty(paramName))
{
if (paramTypeId == "Variant")
{
paramName = "variantId";
}
else if (isQuantifier)
{
paramName = "pluralCount";
}
else
{
paramName = "param" + paramType.type + paramIndex;
}
}
var functionParam = new FunctionFormatTagParameter {
Type = paramType.type.Value, Name = paramName, TypeToCast = paramType.typeToCast, IsVariantId = paramType.isVariantId
};
if (isQuantifier && result.PluralizationParameter == null)
{
result.PluralizationParameter = functionParam;
}
else if (paramTypeId == "Variant")
{
if (result.VariantParameter != null)
{
logger?.LogError($"ReswPlus: The key '{key}' has more than 1 Variant parameter", resourceFilename);
return(null);
}
result.VariantParameter = functionParam;
}
result.Parameters.Add(functionParam);
++paramIndex;
}
}
}
return(result);
}
public void Visit(MethodContext parserRuleContext)
{
//Creo un nuevo contexto dentro de metodos
var context = new ObjectContext(type);
//O_C[SELF_TYPE_type/self] defino la variable self con tipo SELF_TYPE_type
context.Define("self", new SelfType(type, globalContext));
foreach (var formal in parserRuleContext._formals)
{
Visit(formal, context);
}
//Porque los tipo IO y Object no tienen implementacion
if (type == globalContext.IO || type == globalContext.Object || type == globalContext.Int || type == globalContext.String)
{
return;
}
//Visito el cuerpo del metodo
Visit(parserRuleContext.exprBody, context);
var typeMethod = globalContext.GetType(parserRuleContext.TypeReturn.Text, type);
//si al menos un tipo es undefined no se reporta error plq la expresion es null
//Alomejor hay que especificar el nombre del metodo en el error
if (!parserRuleContext.exprBody.computedType.Conform(typeMethod))
{
errorLogger.LogError($"({parserRuleContext.Start.Line},{parserRuleContext.Start.Column+1}) - Type Error : In the method {parserRuleContext.idText} of class {type.Name} the type of the method body {parserRuleContext.exprBody.computedType.Name} not conform to the declared return type {typeMethod.Name}");
}
}
public async Task <string> UpdateProducts([FromBody] ProductLog logData)
{
try
{
var fiProducts = logData.ProductData.OrderByDescending(c => c.ProductId).Take(20);
var host = await _hostCache.GetHostByIdAsync(logData.HostId).ConfigureAwait(false);
if (host == null || host.Id == 0)
{
return(CommonStrings.NoHost);
}
#region SecurityCheck
if (_configurations.SecurityCheck)
{
var origin = Request.Headers[CommonStrings.Origin].ToString();
if (!string.IsNullOrEmpty(origin))
{
var aut = new Uri(origin).Host;
aut = aut.ToLower();
var topdomain = string.Empty;
if (aut.IndexOf(CommonStrings.Dot) == aut.LastIndexOf(CommonStrings.Dot))
{
topdomain = aut;
}
else
{
topdomain = aut.Substring(aut.IndexOf(CommonStrings.Dot) + 1);
}
if (host.Host != topdomain)
{
return(CommonStrings.NoHostAccess);
}
}
}
#endregion
if (logData != null && (await _crowlerCache.IsCrowler(logData.UserId)))
{
return(string.Empty);
}
List <Task> tasks = new List <Task>
{
_totalVisitUpdater.UpdateTotalVisit(logData.HostId)
};
await _hostScriptChecker.UpdateProductValidation(logData.HostId);
var categoriesforlog = logData.ProductData.Where(c => !string.IsNullOrEmpty(c.Category)).GroupBy(c => c.Category).Select(v => new KeyValuePair <string, int>(v.Key, v.Count()));
foreach (var category in categoriesforlog)
{
tasks.Add(_categoryLogger.LogCategory(host.Id, category.Key, category.Value));
}
foreach (var item in fiProducts)
{
var updateedProduct = new HostProduct()
{
Description = item.Description,
ImageAddress = item.ImageAddress,
IsAvailable = item.Available,
Price = item.Price,
Url = item.PageAddress,
Id = item.ProductId,
ProductName = item.Name,
CategoryName = item.Category,
UpdateDate = DateTime.Now
};
tasks.Add(_productCache.UpdateProduct(logData.HostId, updateedProduct));
}
#region Log Into Kafka
foreach (var item in logData.ProductData)
{
await _kafkaLogger.SendMessage(new DruidData()
{
CategoryName = item.Category,
Date = DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:sszzz"),
HostName = host.Host,
ImageAddress = item.ImageAddress,
Price = item.Price,
ProductName = item.Name,
PageAddress = item.PageAddress,
ProductId = item.ProductId,
StatType = StatTypes.ProductView,
UserId = logData.UserId.ToString(),
HostId = logData.HostId.ToString(),
});
}
#endregion
await Task.WhenAll(tasks).ConfigureAwait(false);
}
catch (Exception ex)
{
await _errorLogger.LogError("Operation:ProductUpdate =>" + ex.Message);
}
return(string.Empty);
}
public void Visit(New node)
{
var type = Context.GetType(node.Type);
if (type == null)
{
errorLog.LogError(string.Format(TypeNotExist, node.Line, node.Type));
node.computedType = Context.GetType("Void");
}
else
{
node.computedType = type;
}
}
public async Task <string> LogUser([FromBody] PageLogRequest pageData)
{
try
{
var innerAddress = new Uri(pageData.Address).PathAndQuery;
var host = await _hostCache.GetHostByIdAsync(pageData.HostId);
if (host == null || host.Id == 0)
{
return(CommonStrings.NoHost);
}
#region SecurityCheck
if (_configurations.SecurityCheck)
{
var origin = Request.Headers[CommonStrings.Origin].ToString();
if (!string.IsNullOrEmpty(origin))
{
var aut = new Uri(origin).Host;
aut = aut.ToLower();
var topdomain = string.Empty;
if (aut.IndexOf(CommonStrings.Dot) == aut.LastIndexOf(CommonStrings.Dot))
{
topdomain = aut;
}
else
{
topdomain = aut.Substring(aut.IndexOf(CommonStrings.Dot) + 1);
}
if (host.Host != topdomain)
{
return(CommonStrings.NoHostAccess);
}
}
}
#endregion
if (pageData != null && (await _crowlerCache.IsCrowler(pageData.UserId)))
{
return("");
}
await _totalVisitUpdater.UpdateTotalVisit(pageData.HostId);
await _hostScriptChecker.UpdatePageValidation(pageData.HostId);
await _kafkaLogger.SendMessage(new DruidData()
{
CategoryName = "",
Date = DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:sszzz"),
HostName = host.Host,
ImageAddress = "",
Price = 0,
ProductName = "",
PageAddress = innerAddress,
ProductId = "",
StatType = StatTypes.PageView,
UserId = pageData.UserId.ToString(),
HostId = pageData.HostId.ToString(),
});
}
catch (Exception ex)
{
await _errorLogger.LogError("Operation:PageLogger =>" + "User=>" + pageData.UserId + ":" + ex.Message);
}
return("");
}
public async Task UpdateProducts([FromBody] RemoveProductLog logData)
{
try
{
var productIds = logData.ProductData.Select(c => c.ProductId);
var productAddress = new Uri(logData.PageAddress).PathAndQuery;
var host = await _hostDictionary.GetHostByIdAsync(logData.HostId);
if (host == null || host.Id == 0)
{
return;
}
#region SecurityCheck
if (_configurations.SecurityCheck)
{
var origin = Request.Headers[CommonStrings.Origin].ToString();
if (!string.IsNullOrEmpty(origin))
{
var aut = new Uri(origin).Host;
aut = aut.ToLower();
var topdomain = string.Empty;
if (aut.IndexOf(CommonStrings.Dot) == aut.LastIndexOf(CommonStrings.Dot))
{
topdomain = aut;
}
else
{
topdomain = aut.Substring(aut.IndexOf(CommonStrings.Dot) + 1);
}
if (host.Host != topdomain)
{
return;
}
}
}
#endregion
await _hostScriptChecker.UpdateBuyValidation(logData.HostId);
foreach (var item in productIds)
{
var cachedProduct = await _productCache.FindProduct(logData.HostId, item);
if (cachedProduct.Id != string.Empty)
{
await _kafkaLogger.SendMessage(new DruidData()
{
CategoryName = cachedProduct.CategoryName,
Date = DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:sszzz"),
HostName = host.Host,
ImageAddress = cachedProduct.ImageAddress,
Price = cachedProduct.Price,
ProductName = cachedProduct.ProductName,
PageAddress = cachedProduct.Url,
ProductId = item,
StatType = StatTypes.ProductPurchase,
UserId = logData.UserId.ToString(),
HostId = logData.HostId.ToString(),
});
}
}
}
catch (Exception ex)
{
await _errorLogger.LogError("Operation:Buy =>" + ex.Message);
}
}
private StronglyTypedClass Parse(string content, string defaultNamespace, bool isAdvanced)
{
var namespaceToUse = ExtractNamespace(defaultNamespace);
var resourceFileName = Path.GetFileName(_resourceFileInfo.Path);
var className = Path.GetFileNameWithoutExtension(_resourceFileInfo.Path);
var reswInfo = ReswParser.Parse(content);
var projectNameIfLibrary = _resourceFileInfo.ParentProject.IsLibrary ? _resourceFileInfo.ParentProject.Name : null;
//If the resource file is in a library, the resource id in the .pri file
//will be <library name>/FilenameWithoutExtension
var resouceNameForResourceLoader = string.IsNullOrEmpty(projectNameIfLibrary) ?
className : projectNameIfLibrary + "/" + className;
var result = new StronglyTypedClass()
{
IsAdvanced = isAdvanced,
ClassName = className,
Namespaces = namespaceToUse,
ResoureFile = resouceNameForResourceLoader
};
var stringItems = reswInfo.Items
.Where(i => !i.Key.Contains(".") && !(i.Comment?.Contains(TagIgnore) ?? false)).ToArray();
if (isAdvanced)
{
//check Pluralization
var itemsWithPluralOrVariant = reswInfo.Items.GetItemsWithVariantOrPlural();
var basicItems = stringItems.Except(itemsWithPluralOrVariant.SelectMany(e => e.Items)).ToArray();
foreach (var item in itemsWithPluralOrVariant)
{
if (item.SupportPlural)
{
var idNone = item.Key + "_None";
var hasNoneForm = reswInfo.Items.Any(i => i.Key == idNone);
var singleLineValue = _regexRemoveSpace.Replace(item.Items.FirstOrDefault().Value, " ").Trim();
var summary = $"Get the pluralized version of the string similar to: {singleLineValue}";
PluralLocalization localization;
if (item.SupportVariants)
{
localization = new PluralVariantLocalization()
{
Key = item.Key,
Summary = summary,
SupportNoneState = hasNoneForm,
};
}
else
{
localization = new PluralLocalization()
{
Key = item.Key,
Summary = summary,
SupportNoneState = hasNoneForm,
};
}
if (item.Items.Any(i => i.Comment != null && i.Comment.Contains(Deprecated_TagStrongType)))
{
_logger?.LogError($"{Deprecated_TagStrongType} is no more supported, use {TagFormat} instead. See https://github.com/rudyhuyn/ReswPlus/blob/master/README.md");
}
var commentToUse =
item.Items.FirstOrDefault(i => i.Comment != null && _regexStringFormat.IsMatch(i.Comment));
ManageFormattedFunction(localization, commentToUse?.Comment, basicItems, resourceFileName);
result.Localizations.Add(localization);
}
else if (item.SupportVariants)
{
var singleLineValue = _regexRemoveSpace.Replace(item.Items.FirstOrDefault().Value, " ").Trim();
var summary = $"Get the variant version of the string similar to: {singleLineValue}";
var commentToUse = item.Items.FirstOrDefault(i => i.Comment != null && _regexStringFormat.IsMatch(i.Comment));
var localization = new VariantLocalization()
{
Key = item.Key,
Summary = summary,
};
ManageFormattedFunction(localization, commentToUse?.Comment, basicItems, resourceFileName);
result.Localizations.Add(localization);
}
}
stringItems = basicItems;
}
if (stringItems.Any())
{
foreach (var item in stringItems)
{
var singleLineValue = _regexRemoveSpace.Replace(item.Value, " ").Trim();
var summary = $"Looks up a localized string similar to: {singleLineValue}";
var localization = new RegularLocalization()
{
Key = item.Key,
Summary = summary,
};
if (isAdvanced)
{
ManageFormattedFunction(localization, item.Comment, stringItems, resourceFileName);
}
result.Localizations.Add(localization);
}
}
return(result);
}
public void Visit(ClassContext parserRule)
{
type = globalContext.GetType(parserRule.type.Text);
if (parserRule.inherits != null)
{
if (!globalContext.IfDefineType(parserRule.inherits.Text))
{
errorLogger.LogError($"El tipo con nombre {parserRule.inherits.Text} no ha sido encontrado");
}
if (globalContext.Int.Name == parserRule.inherits.Text)
{
errorLogger.LogError($"El tipo {parserRule.type.Text} no puede heredar de Int");
}
if (globalContext.String.Name == parserRule.inherits.Text)
{
errorLogger.LogError($"El tipo {parserRule.type.Text} no puede heredar de String");
}
if (globalContext.Bool.Name == parserRule.inherits.Text)
{
errorLogger.LogError($"El tipo {parserRule.type.Text} no puede heredar de Bool");
}
var inherits = globalContext.GetType(parserRule.inherits.Text);
type.Inherits = inherits;
if (inherits.Conform(type))
{
errorLogger.LogError("No se permite la herencia cíclica");
}
}
foreach (var item in parserRule._features)
{
Visit(item);
}
//Verifico si la clase Main tiene el metodo main y si este no tiene parametros
if (parserRule.type.Text == "Main")
{
if (type.IsDefineMethod("main"))
{
var main = type.GetMethod("main");
if (main.Formals.Length > 0)
{
errorLogger.LogError("El metodo main no tiene parametros");
}
}
else
{
errorLogger.LogError("El metodo main no esta definido en la clase Main");
}
}
}
public async Task <string> UpdateProducts([FromBody] AddToCartLog logData)
{
try
{
var host = await _hostCache.GetHostByIdAsync(logData.HostId);
if (host == null || host.Id == 0)
{
return(CommonStrings.NoHost);
}
#region SecurityCheck
if (_configurations.SecurityCheck)
{
var origin = Request.Headers[CommonStrings.Origin].ToString();
if (!string.IsNullOrEmpty(origin))
{
var aut = new Uri(origin).Host;
aut = aut.ToLower();
var topdomain = string.Empty;
if (aut.IndexOf(CommonStrings.Dot) == aut.LastIndexOf(CommonStrings.Dot))
{
topdomain = aut;
}
else
{
topdomain = aut.Substring(aut.IndexOf(CommonStrings.Dot) + 1);
}
if (host.Host != topdomain)
{
return(CommonStrings.NoHostAccess);
}
}
}
#endregion
var productad = logData.ProductData.OrderByDescending(c => c.ProductId).ToList();
if (!productad.Any())
{
return(string.Empty);
}
await _hostScriptChecker.UpdateCartValidation(logData.HostId);
await _totalVisitUpdater.UpdateTotalVisit(logData.HostId);
foreach (var item in productad)
{
var cachedProduct = await _productCache.FindProduct(logData.HostId, item.ProductId);
if (cachedProduct.Id != string.Empty)
{
await _kafkaLogger.SendMessage(new DruidData()
{
CategoryName = cachedProduct.CategoryName,
Date = DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:sszzz"),
HostName = host.Host,
ImageAddress = cachedProduct.ImageAddress,
Price = cachedProduct.Price,
ProductName = cachedProduct.ProductName,
PageAddress = cachedProduct.Url,
ProductId = item.ProductId,
StatType = StatTypes.AddToCart,
UserId = logData.UserId.ToString(),
HostId = logData.HostId.ToString(),
});
}
}
}
catch (Exception ex)
{
await _errorLogger.LogError("Operations:AdToCart->" + ex.Message);
}
return("");
}
public async Task Invoke(HttpContext context)
{
try
{
context.Response.ContentType = "text/html";
var requestHost = context.Request.Headers["Referer"];
if (string.IsNullOrEmpty(requestHost))
{
await context.Response.WriteAsync("No Iframe! Don't Cheat!");
return;
}
string host = new Uri(requestHost).Authority.ToString();
var topdomain = "";
if (host.IndexOf(".") == host.LastIndexOf("."))
{
topdomain = host;
}
else
{
topdomain = host.Substring(host.IndexOf(".") + 1);
}
var hostData = await _hostCache.GetHostAsync(topdomain);
if (hostData == null)
{
return;
}
string userCookie = context.Request.Cookies[_configuration.CookieName];
//try
//{
// var logAgent= _redisCache.GetDatabase(DataAccess.RedisDatabases.CacheData).StringGet("LogAgent");
// if (logAgent.HasValue)
// {
// var userAgent = context.Request.Headers["User-Agent"].ToString();
// var agentstring = string.IsNullOrEmpty(userAgent.ToString()) ? "unknown" : userAgent.ToString();
// var agentDb = _redisCache.GetDatabase(DataAccess.RedisDatabases.Logs);
// await agentDb.HashIncrementAsync("AgentCounter",agentstring);
// }
//}
//catch
//{
//}
long userId = 0;
if (userCookie == null)
{
userId = await _userIdSetter.GetNewUserIdAsync();
var co = new CookieOptions()
{
Expires = DateTime.Now.AddYears(5),
SameSite = SameSiteMode.None
};
if (_configuration.CookieDomain != ".")
{
co.Domain = _configuration.CookieDomain;
}
context.Response.Cookies.Append(_configuration.CookieName, userId.ToString(), co);
}
else
{
var resultofparseCookie = long.TryParse(userCookie, out userId);
if (!resultofparseCookie)
{
return;
}
}
if (await _crowlerCache.IsCrowler(userId))
{
return;
}
var rawhtml = "<!DOCTYPE html><html><head><meta charset=\"utf-8\" /><title></title></head><body>partner_iframes<script>var sendingData = {};sendingData.message = \"GetCookie\";sendingData.UserId = user_identity;sendingData.FinalizePage = 'finalize_page';sendingData.HostId = host_identity;sendingData.AddToCart = 'add_to_cart';parent.postMessage(JSON.stringify(sendingData), \"*\");</script></body></html>";
var html = rawhtml.Replace("user_identity", userId.ToString()).Replace("host_identity", hostData.Id.ToString()).Replace("add_to_cart", hostData.AddToCardId).Replace("finalize_page", hostData.FinalizePage);
var partners = await _partnerCache.ListAsync();
var pixelHtml = "";
foreach (var item in partners)
{
if (!string.IsNullOrEmpty(item.CookieSyncAddress))
{
var partnerAddress = item.CookieSyncAddress?.Replace("@StickyId", userId.ToString());
pixelHtml += "<iframe src=\"" + partnerAddress + "\"></iframe>";
}
}
html = html.Replace("partner_iframes", pixelHtml);
await context.Response.WriteAsync(html);
}
catch (Exception ex)
{
await _errorLogger.LogError(ex.Message);
}
}
