public static void BuildLines(List <Currency> currencies, List <Indicator> indicators, List <Watcher> watchers, List <DataPoint> lines, int dependencyLevel, int stopAt)
{
foreach (var currency in currencies)
{
foreach (var indicator in indicators)
{
if (indicator.DependencyLevel == dependencyLevel) // We set the consecutive ones
{
// Get latest line for this currency indicator pair
var line = lines.FirstOrDefault(LineExpression.Line(lines[0].Time, currency.CurrencyId, indicator.IndicatorId).Compile());
// Get all watchers for this currency indicator pair
var filteredWatchers = watchers.Where(WatcherExpression.WatcherFilter(null, currency.CurrencyId, indicator.IndicatorId).Compile()).ToList();
// Build
var value = IndicatorBuilder.BuildValue(currency, indicator, lines);
var averageBuy = IndicatorBuilder.BuildAverageBuy(filteredWatchers);
var averageSell = IndicatorBuilder.BuildAverageSell(filteredWatchers);
// Set
line?.Set(value, averageBuy, averageSell);
}
}
}
// Do the same with the next level recursively
if (dependencyLevel < stopAt)
{
BuildLines(currencies, indicators, watchers, lines, dependencyLevel + 1, stopAt);
}
}
public async Task <List <Order> > UpdateOrders(List <Watcher> watchers)
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Grab watchers willing to buy or sell
watchers = watchers.Where(WatcherExpression.WatcherWillingToBuyOrSell().Compile()).ToList();
// Get all orders
var orders = await _mainDbContext.Orders.ToListAsync();
// Build new orders
var newOrders = OrderBuilder.BuildNewOrders(watchers, orders);
// Add
_mainDbContext.Orders.AddRange(newOrders);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log into Splunk
_logger.LogSplunkInformation("UpdateOrders", new
{
newOrders.Count,
ExecutionTime = stopwatch.Elapsed.TotalSeconds
});
// Return
return(newOrders);
}
public async Task <List <Line> > AddNewLines(List <Currency> currencies, List <Indicator> indicators)
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get watchers willing to buy or sell
var watchers = await _mainDbContext.Watchers.Where(WatcherExpression.WatcherSet()).ToListAsync();
// Build new lines
var lines = LineBuilder.BuildLines(currencies, indicators, watchers);
// Set new lines
_mainDbContext.Lines.AddRange(lines);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log
_logger.LogInformation("{@Event}, {@Count}, {@ExecutionTime}", "NewLinesAdded", lines.Count, stopwatch.Elapsed.TotalSeconds);
// Return
return(lines);
}
public async Task <List <Order> > AddOrders(List <Watcher> watchers)
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Grab watchers willing to buy or sell
watchers = watchers.Where(WatcherExpression.WatcherBuyingOrSelling().Compile()).ToList();
// Build new orders
var newOrders = OrderBuilder.BuildNewOrders(watchers);
// Add
_mainDbContext.Orders.AddRange(newOrders);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log
_logger.LogInformation("{@Event}, {@Count}, {@ExecutionTime}", "OrdersAdded", newOrders.Count, stopwatch.Elapsed.TotalSeconds);
// Return
return(newOrders);
}
public async Task <List <Watcher> > UpdateWatchers(List <Watcher> defaultWatchers)
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get all watchers
var watchers = await _mainDbContext.Watchers.Where(WatcherExpression.NonDefaultWatcher()).ToListAsync();
// Sync watchers
watchers.SyncWatchers(defaultWatchers);
// Update
_mainDbContext.Watchers.UpdateRange(watchers);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log
_logger.LogInformation("{@Event}, {@Count}, {@ExecutionTime}", "WatchersUpdated", watchers.Count, stopwatch.Elapsed.TotalSeconds);
// Return
return(watchers);
}
public async Task <List <Responses.Watcher> > GetAllWatchers(string userId = null, string currencyId = null, string indicatorId = null)
{
// Get user
var user = await _userRepository.GetSingle(userId);
// Check if it exists
if (user == null)
{
throw new NotFoundException(UserMessage.UserNotFound);
}
// Get all watchers
var userWatchers = await _watcherRepository.GetAll(WatcherExpression.WatcherFilter(userId, currencyId, indicatorId));
// Get all default watchers
var defaultWatchers = await _watcherRepository.GetAll(WatcherExpression.DefaultWatcher(currencyId, indicatorId));
// Build with defaults
userWatchers = WatcherBuilder.BuildWatchersWithDefaults(userWatchers, defaultWatchers);
// Response
var response = _mapper.Map <List <Responses.Watcher> >(userWatchers);
// Return
return(response);
}
public static WatcherStatus BuildStatus(Watcher watcher)
{
// Evaluate and return
if (WatcherExpression.WatcherNotSet().Invoke(watcher))
{
return(WatcherStatus.NOT_SET);
}
if (WatcherExpression.WatcherBuying().Invoke(watcher))
{
return(WatcherStatus.BUYING);
}
if (WatcherExpression.WatcherSelling().Invoke(watcher))
{
return(WatcherStatus.SELLING);
}
if (WatcherExpression.WatcherBought().Invoke(watcher))
{
return(WatcherStatus.BOUGHT);
}
if (WatcherExpression.WatcherHolding().Invoke(watcher))
{
return(WatcherStatus.HOLDING);
}
if (WatcherExpression.WatcherSold().Invoke(watcher))
{
return(WatcherStatus.SOLD);
}
throw new NotImplementedException();
}
public async Task <List <Watcher> > UpdateDefaultWatchers(List <Line> lines)
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Build default watchers
var newDefaultWatchers = WatcherBuilder.BuildDefaultWatchers(lines);
// Get all default watchers
var defaultWatchers = await _mainDbContext.Watchers.Where(WatcherExpression.DefaultWatcher()).ToListAsync();
// Update
_mainDbContext.UpdateCollection(defaultWatchers, newDefaultWatchers);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log
_logger.LogInformation("{@Event}, {@Count}, {@ExecutionTime}", "DefaultWatchersUpdated", newDefaultWatchers.Count, stopwatch.Elapsed.TotalSeconds);
// Return
return(newDefaultWatchers);
}
public async Task <List <Line> > UpdateLines(List <Currency> currencies, List <Indicator> indicators)
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get watchers willing to buy or sell
var watchers = await _mainDbContext.Watchers.Where(WatcherExpression.WatcherWillingToBuyOrSell()).ToListAsync();
// Build new lines
var lines = LineBuilder.BuildLines(currencies, indicators, watchers);
// Set new lines
_mainDbContext.Lines.AddRange(lines);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log into Splunk
_logger.LogSplunkInformation("UpdateLines", new
{
lines.Count,
ExecutionTime = stopwatch.Elapsed.TotalSeconds
});
// Return
return(lines);
}
public static decimal?BuildWeightedAverageBuy(List <Watcher> watchers)
{
// Watchers buying
var watcherWillingToBuy = watchers.Where(WatcherExpression.WatcherBuying()).ToList();
// Return if no watchers
if (watcherWillingToBuy.Count == 0)
{
return(null);
}
// Total quantity
var totalQuantity = watcherWillingToBuy.Select(x => x.Quantity).Sum();
// Weights
var weights = watcherWillingToBuy.Select(x => x.Buy * x.Quantity);
// Total weight
var totalWeight = weights.Sum();
// Weighted average
var weightedAverage = totalWeight / totalQuantity;
// Return
return(weightedAverage);
}
public async Task <List <Responses.Watcher> > GetUserWatchers(string userId = null, string currencyId = null, string indicatorId = null)
{
// Get user
var user = await _mainDbContext.Users.FindAsync(userId);
// Check if it exists
if (user == null)
{
throw new NotFoundException(UserMessage.UserNotFound);
}
// Filter user watchers
var userWatchers = await _mainDbContext.Watchers.Where(WatcherExpression.WatcherFilter(userId, currencyId, indicatorId)).ToListAsync();
// Get all default watchers
var defaultWatchers = await _mainDbContext.Watchers.Where(WatcherExpression.DefaultWatcher(currencyId, indicatorId)).ToListAsync();
// Build with defaults
userWatchers = WatcherBuilder.BuildWatchersWithDefaults(userWatchers, defaultWatchers);
// Response
var response = _mapper.Map <List <Responses.Watcher> >(userWatchers);
// Return
return(response);
}
public async Task <Responses.Watcher> AddWatcher(AddWatcher request)
{
// Get user
var user = await _userRepository.GetSingle(request.UserId);
// Throw NotFound if the currency does not exist
if (user == null)
{
throw new NotFoundException(UserMessage.UserNotFound);
}
// Get indicator
var indicator = await _indicatorRepository.GetSingle(request.IndicatorId);
// Throw NotFound if the currency does not exist
if (indicator == null)
{
throw new NotFoundException(IndicatorMessage.IndicatorNotFound);
}
// Check if it exists
var watcher = await _watcherRepository.GetSingle(WatcherExpression.Watcher(request.UserId, request.CurrencyId, request.IndicatorId));
// Throw ConflictException if it exists
if (watcher != null)
{
throw new ConflictException(WatcherMessage.WatcherAlreadyExists);
}
// Get default watcher
var defaultWatcher = await _watcherRepository.GetSingle(WatcherExpression.DefaultWatcher(request.CurrencyId, request.IndicatorId));
// Add
watcher = new Watcher(
request.UserId,
request.CurrencyId,
request.IndicatorId,
request.IndicatorType,
defaultWatcher?.Value,
request.Buy,
request.Sell,
defaultWatcher?.AverageBuy,
defaultWatcher?.AverageSell,
request.Enabled,
DateTime.Now);
_watcherRepository.Add(watcher);
// Save
await _dbContext.SaveChangesAsync();
// Log into Splunk
_logger.LogSplunkInformation(request);
// Response
var response = _mapper.Map <Responses.Watcher>(watcher);
// Return
return(response);
}
public async Task <Responses.Watcher> SetWatcher(SetWatcher request)
{
// Get watcher
var watcher = await _mainDbContext.Watchers.FindAsync(request.WatcherId);
// Watcher not found
if (watcher == null)
{
throw new NotFoundException(WatcherMessage.WatcherNotFound);
}
// Buy limit must be lower than watcher value
if (WatcherExpression.BuyLimitMustBeLowerThanWatcherValue(request.Buy).Invoke(watcher))
{
throw new ConflictException(new Conflict <SetWatcherConflictReason>(SetWatcherConflictReason.BUY_LIMIT_MUST_BE_LOWER_THAN_WATCHER_VALUE, string.Format(WatcherMessage.BuyLimitMustBeLowerThanWatcherValue, watcher.Value)));
}
// Sell limit must be higher than watcher value
if (WatcherExpression.SellLimitMustBeHigherThanWatcherValue(request.Sell).Invoke(watcher))
{
throw new ConflictException(new Conflict <SetWatcherConflictReason>(SetWatcherConflictReason.SELL_LIMIT_MUST_BE_HIGHER_THAN_WATCHER_VALUE, string.Format(WatcherMessage.SellLimitMustBeHigherThanWatcherValue, watcher.Value)));
}
// Watcher already got liquidated
if (WatcherExpression.WatcherSold().Invoke(watcher))
{
throw new ConflictException(new Conflict <SetWatcherConflictReason>(SetWatcherConflictReason.WATCHER_ALREADY_LIQUIDATED, WatcherMessage.WatcherAlreadyLiquidated));
}
// Watcher already bought
if (WatcherExpression.WatcherAlreadyBought(request.Buy).Invoke(watcher))
{
throw new ConflictException(new Conflict <SetWatcherConflictReason>(SetWatcherConflictReason.WATCHER_ALREADY_BOUGHT, string.Format(WatcherMessage.WatcherAlreadyBought, watcher.EntryPrice)));
}
// Watcher already sold
if (WatcherExpression.WatcherAlreadySold(request.Sell).Invoke(watcher))
{
throw new ConflictException(new Conflict <SetWatcherConflictReason>(SetWatcherConflictReason.WATCHER_ALREADY_SOLD, string.Format(WatcherMessage.WatcherAlreadySold, watcher.EntryPrice)));
}
// Set watcher
watcher.Set(request.Buy, request.Sell, request.Quantity);
// Update
_mainDbContext.Watchers.Update(watcher);
// Save
await _mainDbContext.SaveChangesAsync();
// Response
var response = _mapper.Map <Responses.Watcher>(watcher);
// Log
_logger.LogInformation("{@Event}, {@UserId}, {@Request}, {@Response}", "WatcherSet", request.UserId, request, response);
// Return
return(response);
}
public async Task Run()
{
try
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get all currencies
var currencies = await _currencyRepository.GetAll();
// Get all indicators
var indicators = await _indicatorRepository.GetAll();
// Set all indicators dependencies
await SetIndicatorDependencies(indicators);
// Get non-default watchers with buy or sell
var watchers = await _watcherRepository.GetAll(WatcherExpression.WatcherWillingToBuyOrSell());
// Set current lines as no longer current
await SetCurrentLinesAsNoLongerCurrent();
// Build new lines
var lines = LineBuilder.BuildLines(currencies, indicators, watchers);
// Set new lines
_lineRepository.AddRange(lines);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log into Splunk
_logger.LogSplunkJob(new
{
lines.Count,
ExecutionTime = stopwatch.Elapsed.TotalSeconds
});
// Return
await Task.CompletedTask;
}
catch (Exception ex)
{
// Log into Splunk
_logger.LogSplunkJob(new
{
JobFailed = ex.Message
});
// Log error into Splunk
_logger.LogSplunkError(ex);
}
}
public void Test_WatcherLiquidated()
{
// Arrange
var watchersBuyingAndSelling = FakeWatcher.GetWatchersLiquidated();
// Act
var filter = watchersBuyingAndSelling.Where(WatcherExpression.WatcherSold()).ToList();
// Assert
Assert.AreEqual(watchersBuyingAndSelling.Count, filter.Count);
}
public void Test_WatcherBuyingOrSelling()
{
// Arrange
var watchersBuyingAndSelling = FakeWatcher.GetWatchersBuyingAndSelling();
// Act
var filter = watchersBuyingAndSelling.Where(WatcherExpression.WatcherBuyingOrSelling().Compile()).ToList();
// Assert
Assert.AreEqual(watchersBuyingAndSelling.Count, filter.Count);
}
public static void SyncWatchers(this List <Watcher> watchers, List <Watcher> defaultWatchers)
{
// Sync watcher
foreach (var watcher in watchers)
{
var defaultWatcher = defaultWatchers.FirstOrDefault(WatcherExpression.DefaultWatcher(watcher.CurrencyId, watcher.IndicatorId).Compile());
if (defaultWatcher != null)
{
watcher.Sync(defaultWatcher.Value, defaultWatcher.AverageBuy, defaultWatcher.AverageSell, defaultWatcher.Price);
}
}
}
public async Task Run()
{
try
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get all watchers with buy or sells
var watchers = await _watcherRepository.GetAll(WatcherExpression.WatcherWillingToBuyOrSell());
// Get all orders
var orders = await _orderRepository.GetAll();
// Build new orders
var newOrders = OrderBuilder.BuildNewOrders(watchers, orders);
// Add
_orderRepository.AddRange(newOrders);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log into Splunk
_logger.LogSplunkJob(new
{
newOrders.Count,
ExecutionTime = stopwatch.Elapsed.TotalSeconds
});
// Return
await Task.CompletedTask;
}
catch (Exception ex)
{
// Log into Splunk
_logger.LogSplunkJob(new
{
JobFailed = ex.Message
});
// Log error into Splunk
_logger.LogSplunkError(ex);
}
}
public async Task Run()
{
try
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get current lines
var currentLines = await _lineRepository.GetAll(LineExpression.CurrentLine());
// Build default watchers
var newDefaultWatchers = WatcherBuilder.BuildDefaultWatchers(currentLines);
// Get all default watchers
var defaultWatchers = await _watcherRepository.GetAll(WatcherExpression.DefaultWatcher());
// Update
_watcherRepository.UpdateCollection(defaultWatchers, newDefaultWatchers);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log into Splunk
_logger.LogSplunkJob(new
{
newDefaultWatchers.Count,
ExecutionTime = stopwatch.Elapsed.TotalSeconds
});
// Return
await Task.CompletedTask;
}
catch (Exception ex)
{
// Log into Splunk
_logger.LogSplunkJob(new
{
JobFailed = ex.Message
});
// Log error into Splunk
_logger.LogSplunkError(ex);
}
}
public async Task Run()
{
try
{
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get all watchers
var watchers = await _watcherRepository.GetAll();
// Get all default watchers
var defaultWatchers = await _watcherRepository.GetAll(WatcherExpression.DefaultWatcher());
// Sync watchers
watchers.SyncWatchers(defaultWatchers);
// Save
await _mainDbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log into Splunk
_logger.LogSplunkJob(new
{
watchers.Count,
ExecutionTime = stopwatch.Elapsed.TotalSeconds
});
// Return
await Task.CompletedTask;
}
catch (Exception ex)
{
// Log into Splunk
_logger.LogSplunkJob(new
{
JobFailed = ex.Message
});
// Log error into Splunk
_logger.LogSplunkError(ex);
}
}
public async Task <List <Watcher> > UpdateDefaultWatchers(List <Line> lines)
{
// Return if there are no lines
if (lines.Count == 0)
{
return(new List <Watcher>());
}
// Start watch
var stopwatch = new Stopwatch();
stopwatch.Start();
// Get newest time
var newestTime = lines.Max(x => x.Time);
// Get current lines
var currentLines = await _lineRepository.GetAll(LineExpression.CurrentLine(newestTime));
// Build default watchers
var newDefaultWatchers = WatcherBuilder.BuildDefaultWatchers(currentLines);
// Get all default watchers
var defaultWatchers = await _watcherRepository.GetAll(WatcherExpression.DefaultWatcher());
// Update
_watcherRepository.UpdateCollection(defaultWatchers, newDefaultWatchers);
// Save
await _dbContext.SaveChangesAsync();
// Stop watch
stopwatch.Stop();
// Log into Splunk
_logger.LogSplunkInformation("UpdateDefaultWatchers", new
{
newDefaultWatchers.Count,
ExecutionTime = stopwatch.Elapsed.TotalSeconds
});
// Return
return(defaultWatchers);
}
public static void SyncWatchers(this List <Watcher> watchers, List <Watcher> defaultWatchers)
{
// Sync watcher
foreach (var watcher in watchers)
{
// We skip default watchers
if (watcher.UserId == "master")
{
continue;
}
var currencyId = watcher.CurrencyId;
var indicatorId = watcher.IndicatorId;
var defaultWatcher = defaultWatchers.FirstOrDefault(WatcherExpression.DefaultWatcher(currencyId, indicatorId).Compile());
if (defaultWatcher != null)
{
watcher.Sync(defaultWatcher.Value, defaultWatcher.AverageBuy, defaultWatcher.AverageSell);
}
}
}
public static List <DataPoint> BuildLines(List <Currency> currencies, List <Indicator> indicators, List <Watcher> watchers)
{
var lines = new List <DataPoint>();
var time = DateTime.Now;
var stopAt = indicators.Count > 0 ? indicators.Max(x => x.DependencyLevel) : 0;
// We create the lines in the order that is given. We build the first level (DependencyLevel = 0) for now
foreach (var currency in currencies)
{
foreach (var indicator in indicators)
{
decimal?value = null;
decimal?averageBuy = null;
decimal?averageSell = null;
if (indicator.DependencyLevel == 0)
{
// Get all watchers for this currency indicator pair
var filteredWatchers = watchers.Where(WatcherExpression.WatcherFilter(null, currency.CurrencyId, indicator.IndicatorId).Compile()).ToList();
// Build
value = IndicatorBuilder.BuildValue(currency, indicator);
averageBuy = IndicatorBuilder.BuildAverageBuy(filteredWatchers);
averageSell = IndicatorBuilder.BuildAverageSell(filteredWatchers);
}
// Add
var dataPoint = new DataPoint(currency.CurrencyId, indicator.IndicatorId, indicator.IndicatorType, indicator.UserId, value, averageBuy, averageSell, true, time);
lines.Add(dataPoint);
}
}
// Now we build the deper levels
if (stopAt > 0)
{
BuildLines(currencies, indicators, watchers, lines, 1, stopAt);
}
// Return
return(lines);
}
public static void BuildLines(List <Currency> currencies, List <Indicator> indicators, List <Watcher> watchers, List <Line> lines, DateTime time, int dependencyLevel, int stopAt)
{
// For each currency
foreach (var currency in currencies)
{
// For each indicator of the given level
foreach (var indicator in indicators.Where(x => x.DependencyLevel == dependencyLevel))
{
// Get all watchers for this currency indicator pair
var filteredWatchers = watchers.Where(WatcherExpression.Filter(null, currency.CurrencyId, indicator.IndicatorId).Compile()).ToList();
// Build value and averages
var value = IndicatorBuilder.BuildValue(currency, indicator, lines);
var averageBuy = BuildWeightedAverageBuy(filteredWatchers);
var averageSell = BuildWeightedAverageSell(filteredWatchers);
// Create line
var line = new Line(
time,
indicator.UserId,
currency.CurrencyId,
indicator.IndicatorId,
value,
averageBuy,
averageSell,
currency.Price);
// Add line
lines.Add(line);
}
}
// Do the same with the next level recursively
if (dependencyLevel < stopAt)
{
BuildLines(currencies, indicators, watchers, lines, time, dependencyLevel + 1, stopAt);
}
}
public async Task <Responses.Watcher> AddWatcher(AddWatcher request)
{
// Get currency
var currency = await _mainDbContext.Currencies.FindAsync(request.CurrencyId);
// Watcher not found
if (currency == null)
{
throw new NotFoundException(CurrencyMessage.CurrencyNotFound);
}
// Get user
var user = await _mainDbContext.Users.FindAsync(request.UserId);
// User not found
if (user == null)
{
throw new NotFoundException(UserMessage.UserNotFound);
}
// Get indicator
var indicator = await _mainDbContext.Indicators.FindAsync(request.IndicatorId);
// Indicator not found
if (indicator == null)
{
throw new NotFoundException(IndicatorMessage.IndicatorNotFound);
}
// Get watcher
var watcher = await _mainDbContext.Watchers.FirstOrDefaultAsync(WatcherExpression.Unique(request.UserId, request.CurrencyId, indicator.UserId, indicator.IndicatorId));
// Watcher already exists
if (watcher != null)
{
throw new ConflictException(new Conflict <AddWatcherConflictReason>(AddWatcherConflictReason.WATCHER_ALREADY_EXISTS, WatcherMessage.WatcherAlreadyExists));
}
// Get default watcher
var defaultWatcher = await _mainDbContext.Watchers.FirstOrDefaultAsync(WatcherExpression.DefaultWatcher(request.CurrencyId, request.IndicatorId));
// Add watcher
watcher = new Watcher(
request.UserId,
request.CurrencyId,
indicator.IndicatorId,
defaultWatcher?.Value,
null,
null,
null,
defaultWatcher?.AverageBuy,
defaultWatcher?.AverageSell,
defaultWatcher?.Price,
request.Enabled,
DateTime.UtcNow.StripSeconds());
// Add
_mainDbContext.Watchers.Add(watcher);
// Save
await _mainDbContext.SaveChangesAsync();
// Response
var response = _mapper.Map <Responses.Watcher>(watcher);
// Log
_logger.LogInformation("{@Event}, {@UserId}, {@Request}, {@Response}", "WatcherAdded", request.UserId, request, response);
// Return
return(response);
}
