public async Task QueueItemAsync(RequestedModel request, string id, RequestType type, FaultType faultType, string description = null)
{
//Ensure there is not a duplicate queued item
var existingItem = await RequestQueue.CustomAsync(async connection =>
{
connection.Open();
var result = await connection.QueryAsync <RequestQueue>("select * from RequestFaultQueue where PrimaryIdentifier = @ProviderId", new { ProviderId = id });
return(result);
});
if (existingItem.FirstOrDefault() != null)
{
// It's already in the queue
return;
}
var queue = new RequestQueue
{
Type = type,
Content = ByteConverterHelper.ReturnBytes(request),
PrimaryIdentifier = id,
FaultType = faultType,
Message = description ?? string.Empty
};
await RequestQueue.InsertAsync(queue);
}
public void QueueItem(RequestedModel request, string id, RequestType type, FaultType faultType)
{
//Ensure there is not a duplicate queued item
var existingItem = RequestQueue.Custom(
connection =>
{
connection.Open();
var result = connection.Query <RequestQueue>("select * from RequestQueue where PrimaryIdentifier = @ProviderId", new { ProviderId = id });
return(result);
}).FirstOrDefault();
if (existingItem != null)
{
// It's already in the queue
return;
}
var queue = new RequestQueue
{
Type = type,
Content = ByteConverterHelper.ReturnBytes(request),
PrimaryIdentifier = id,
FaultType = faultType
};
RequestQueue.Insert(queue);
}
/// <summary>
/// Attempts to set a registry value for the key provided using the specified
/// name, data and kind. If the registry value does not exist it will be created
/// </summary>
/// <param name="key">The key of which the value is to be set for.</param>
/// <param name="name">The name of the value.</param>
/// <param name="data">The data of the value</param>
/// <param name="kind">The value kind of the value</param>
/// <returns>Returns a boolean value if the action succeeded or failed.</returns>
public static bool SetValueSafe(this RegistryKey key, string name, object data, RegistryValueKind kind)
{
try
{
// handle type conversion
if (kind != RegistryValueKind.Binary && data.GetType() == typeof(byte[]))
{
switch (kind)
{
case RegistryValueKind.String:
case RegistryValueKind.ExpandString:
data = ByteConverterHelper.ToString((byte[])data);
break;
case RegistryValueKind.DWord:
data = ByteConverterHelper.ToUInt32((byte[])data);
break;
case RegistryValueKind.QWord:
data = ByteConverterHelper.ToUInt64((byte[])data);
break;
case RegistryValueKind.MultiString:
data = ByteConverterHelper.ToStringArray((byte[])data);
break;
}
}
key.SetValue(name, data, kind);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Gets the username this could be the alias! We should always use this method when getting the username
/// </summary>
/// <param name="username">The username.</param>
/// <param name="session"></param>
/// <returns>
/// <c>null</c> if we cannot find a user
/// </returns>
public string GetUsername(string username, ISession session)
{
var plexUser = PlexUsers.GetUserByUsername(username);
if (plexUser != null)
{
return(!string.IsNullOrEmpty(plexUser.UserAlias) ? plexUser.UserAlias : plexUser.Username);
}
var dbUser = UserRepository.GetUserByUsername(username);
if (dbUser != null)
{
var userProps = ByteConverterHelper.ReturnObject <UserProperties>(dbUser.UserProperties);
return(!string.IsNullOrEmpty(userProps.UserAlias) ? userProps.UserAlias : dbUser.UserName);
}
// could be a local user
var hasSessionKey = session[SessionKeys.UsernameKey] != null;
if (hasSessionKey)
{
return((string)session[SessionKeys.UsernameKey]);
}
return(string.Empty);
}
public PlexContent GetTvShow(PlexContent[] plexShows, string title, string year, string providerId = null,
int[] seasons = null)
{
var advanced = !string.IsNullOrEmpty(providerId);
foreach (var show in plexShows)
{
if (advanced)
{
if (show.ProviderId == providerId && seasons != null)
{
var showSeasons = ByteConverterHelper.ReturnObject <int[]>(show.Seasons);
if (seasons.Any(season => showSeasons.Contains(season)))
{
return(show);
}
return(null);
}
if (!string.IsNullOrEmpty(show.ProviderId) &&
show.ProviderId.Equals(providerId, StringComparison.InvariantCultureIgnoreCase))
{
return(show);
}
}
if (show.Title.Equals(title, StringComparison.CurrentCultureIgnoreCase) &&
show.ReleaseYear.Equals(year, StringComparison.CurrentCultureIgnoreCase))
{
return(show);
}
}
return(null);
}
public RequestedModel CheckRequest(string musicId)
{
var blobs = Repo.GetAll();
var blob = blobs.FirstOrDefault(x => x.MusicId == musicId);
return(blob != null?ByteConverterHelper.ReturnObject <RequestedModel>(blob.Content) : null);
}
private UserManagementUsersViewModel MapLocalUser(UsersModel user, DateTime lastLoggedIn)
{
var features = (Features)user.Features;
var permissions = (Permissions)user.Permissions;
var userProps = ByteConverterHelper.ReturnObject <UserProperties>(user.UserProperties);
var m = new UserManagementUsersViewModel
{
Id = user.UserGuid,
PermissionsFormattedString = permissions == 0 ? "None" : permissions.ToString(),
FeaturesFormattedString = features.ToString(),
Username = user.UserName,
Type = UserType.LocalUser,
EmailAddress = userProps.EmailAddress,
Alias = userProps.UserAlias,
LastLoggedIn = lastLoggedIn,
};
m.Permissions.AddRange(GetPermissions(permissions));
m.Features.AddRange(GetFeatures(features));
return(m);
}
private void okButton_Click(object sender, EventArgs e)
{
_value.Data = ByteConverterHelper.GetBytes(valueDataTxtBox.Text.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));
this.Tag = _value;
this.DialogResult = DialogResult.OK;
this.Close();
}
public static string RegistryValueToString(RegValueData value)
{
switch (value.Kind)
{
case RegistryValueKind.Binary:
return(value.Data.Length > 0 ? BitConverter.ToString(value.Data).Replace("-", " ").ToLower() : "(zero-length binary value)");
case RegistryValueKind.MultiString:
return(string.Join(" ", ByteConverterHelper.ToStringArray(value.Data)));
case RegistryValueKind.DWord:
var dword = ByteConverterHelper.ToUInt32(value.Data);
return($"0x{dword:x8} ({dword})"); // show hexadecimal and decimal
case RegistryValueKind.QWord:
var qword = ByteConverterHelper.ToUInt64(value.Data);
return($"0x{qword:x8} ({qword})"); // show hexadecimal and decimal
case RegistryValueKind.String:
case RegistryValueKind.ExpandString:
return(ByteConverterHelper.ToString(value.Data));
default:
return(string.Empty);
}
}
public IEnumerable <UserHelperModel> GetUsers()
{
var model = new List <UserHelperModel>();
var localUsers = LocalUserRepository.GetAll();
var plexUsers = PlexUserRepository.GetAll();
foreach (var user in localUsers)
{
var props = ByteConverterHelper.ReturnObject <UserProperties>(user.UserProperties);
model.Add(new UserHelperModel
{
Type = UserType.LocalUser,
Username = user.UserName,
UserAlias = props.UserAlias,
EmailAddress = props.EmailAddress,
Permissions = (Permissions)user.Permissions
});
}
model.AddRange(plexUsers.Select(user => new UserHelperModel
{
Type = UserType.LocalUser,
Username = user.Username,
UserAlias = user.UserAlias,
EmailAddress = user.EmailAddress,
Permissions = (Permissions)user.Permissions
}));
return(model);
}
private void okButton_Click(object sender, EventArgs e)
{
_value.Data = ByteConverterHelper.GetBytes(valueDataTxtBox.Text);
this.Tag = _value;
this.DialogResult = DialogResult.OK;
this.Close();
}
public bool UpdateRequest(RequestedModel model)
{
var entity = new RequestBlobs {
Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), ProviderId = model.ProviderId, Id = model.Id
};
return(Repo.Update(entity));
}
public async Task <RequestedModel> CheckRequestAsync(int providerId)
{
var blobs = await Repo.GetAllAsync().ConfigureAwait(false);
var blob = blobs.FirstOrDefault(x => x.ProviderId == providerId);
return(blob != null?ByteConverterHelper.ReturnObject <RequestedModel>(blob.Content) : null);
}
public async Task <bool> BatchDeleteAsync(IEnumerable <RequestedModel> model)
{
var entities = model.Select(m => new RequestBlobs {
Type = m.Type, Content = ByteConverterHelper.ReturnBytes(m), ProviderId = m.ProviderId, Id = m.Id
}).ToList();
return(await Repo.DeleteAllAsync(entities).ConfigureAwait(false));
}
public async Task <bool> UpdateRequestAsync(RequestedModel model)
{
var entity = new RequestBlobs {
Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), ProviderId = model.ProviderId, Id = model.Id
};
return(await Repo.UpdateAsync(entity).ConfigureAwait(false));
}
public async Task DeleteIssueAsync(IssuesModel model)
{
var entity = new IssueBlobs {
Type = model.Type, Content = ByteConverterHelper.ReturnBytes(model), RequestId = model.RequestId, Id = model.Id
};
await Repo.DeleteAsync(entity).ConfigureAwait(false);
}
public bool BatchUpdate(List <RequestedModel> model)
{
var entities = model.Select(m => new RequestBlobs {
Type = m.Type, Content = ByteConverterHelper.ReturnBytes(m), ProviderId = m.ProviderId, Id = m.Id
}).ToList();
return(Repo.UpdateAll(entities));
}
public RegValueEditStringForm(RegValueData value)
{
_value = value;
InitializeComponent();
this.valueNameTxtBox.Text = RegValueHelper.GetName(value.Name);
this.valueDataTxtBox.Text = ByteConverterHelper.ToString(value.Data);
}
public RegValueEditMultiStringForm(RegValueData value)
{
_value = value;
InitializeComponent();
this.valueNameTxtBox.Text = value.Name;
this.valueDataTxtBox.Text = string.Join("\r\n", ByteConverterHelper.ToStringArray(value.Data));
}
/// <summary>
/// Gets the Issues, if there is no issue in the DB we return a <c>new <see cref="IssuesModel"/></c>.
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns></returns>
public async Task <IssuesModel> GetAsync(int id)
{
var blob = await Repo.GetAsync(id);
if (blob == null)
{
return(new IssuesModel());
}
var model = ByteConverterHelper.ReturnObject <IssuesModel>(blob.Content);
return(model);
}
public RequestedModel CheckRequest(int providerId)
{
var blobs = Repo.GetAll();
var blob = blobs.FirstOrDefault(x => x.ProviderId == providerId); if (blob == null)
{
return(null);
}
var model = ByteConverterHelper.ReturnObject <RequestedModel>(blob.Content);
model.Id = blob.Id;
return(model);
}
public async Task <RequestedModel> GetAsync(int id)
{
var blob = await Repo.GetAsync(id).ConfigureAwait(false);
if (blob == null)
{
return(new RequestedModel());
}
var model = ByteConverterHelper.ReturnObject <RequestedModel>(blob.Content);
return(model);
}
public UserHelperModel GetUser(string username)
{
var localUsers = LocalUserRepository.GetUserByUsername(username);
if (localUsers != null)
{
var props = ByteConverterHelper.ReturnObject <UserProperties>(localUsers.UserProperties);
return(new UserHelperModel
{
Type = UserType.LocalUser,
Username = localUsers.UserName,
UserAlias = props.UserAlias,
EmailAddress = props.EmailAddress,
Permissions = (Permissions)localUsers.Permissions,
UserId = localUsers.UserGuid,
Features = (Features)localUsers.Features
});
}
var plexUsers = PlexUserRepository.GetUserByUsername(username);
if (plexUsers != null)
{
return(new UserHelperModel
{
Type = UserType.PlexUser,
Username = plexUsers.Username,
UserAlias = plexUsers.UserAlias,
EmailAddress = plexUsers.EmailAddress,
Permissions = (Permissions)plexUsers.Permissions,
UserId = plexUsers.PlexUserId,
Features = (Features)plexUsers.Features
});
}
var embyUsers = EmbyUserRepository.GetUserByUsername(username);
if (embyUsers != null)
{
return(new UserHelperModel
{
Type = UserType.EmbyUser,
Username = embyUsers.Username,
UserAlias = embyUsers.UserAlias,
EmailAddress = embyUsers.EmailAddress,
Permissions = (Permissions)embyUsers.Permissions,
UserId = embyUsers.EmbyUserId,
Features = (Features)embyUsers.Features
});
}
return(null);
}
public RequestedModel Get(int id)
{
var blob = Repo.Get(id);
if (blob == null)
{
return(new RequestedModel());
}
var model = ByteConverterHelper.ReturnObject <RequestedModel>(blob.Content);
return(model);
}
private void ProcessMissingInformation(List <RequestQueue> requests)
{
if (!requests.Any())
{
return;
}
var sonarrSettings = SonarrSettings.GetSettings();
var sickrageSettings = SickrageSettings.GetSettings();
var tv = requests.Where(x => x.Type == RequestType.TvShow);
// TV
var tvApi = new TvMazeApi();
foreach (var t in tv)
{
var providerId = int.Parse(t.PrimaryIdentifier);
var showInfo = tvApi.ShowLookup(providerId);
if (showInfo.externals?.thetvdb != null)
{
// We now have the info
var tvModel = ByteConverterHelper.ReturnObject <RequestedModel>(t.Content);
tvModel.ProviderId = showInfo.externals.thetvdb.Value;
var result = ProcessTvShow(tvModel, sonarrSettings, sickrageSettings);
if (!result)
{
// we now have the info but couldn't add it, so add it back into the queue but with a different fault
t.Content = ByteConverterHelper.ReturnBytes(tvModel);
t.FaultType = FaultType.RequestFault;
t.LastRetry = DateTime.UtcNow;
Repo.Update(t);
}
else
{
// Make sure it's been requested
var existingRequests = RequestService.GetAll();
var thisItem = existingRequests.Any(x => x.Title.Equals(tvModel.Title));
if (!thisItem)
{
tvModel.Approved = true;
RequestService.AddRequest(tvModel);
}
// Successful, remove from the fault queue
Repo.Delete(t);
}
}
}
}
public RequestedModel Get(int id)
{
var blob = Repo.Get(id);
if (blob == null)
{
return(new RequestedModel());
}
var model = ByteConverterHelper.ReturnObject <RequestedModel>(blob.Content);
model.Id = blob.Id; // They should always be the same, but for somereason a user didn't have it in the db https://github.com/tidusjar/Ombi/issues/862#issuecomment-269743847
return(model);
}
public IEnumerable <UserHelperModel> GetUsersWithPermission(Permissions permission)
{
var model = new List <UserHelperModel>();
var localUsers = LocalUserRepository.GetAll().ToList();
var plexUsers = PlexUserRepository.GetAll().ToList();
var embyUsers = EmbyUserRepository.GetAll().ToList();
var filteredLocal = localUsers.Where(x => ((Permissions)x.Permissions).HasFlag(permission));
var filteredPlex = plexUsers.Where(x => ((Permissions)x.Permissions).HasFlag(permission));
var filteredEmby = embyUsers.Where(x => ((Permissions)x.Permissions).HasFlag(permission));
foreach (var user in filteredLocal)
{
var props = ByteConverterHelper.ReturnObject <UserProperties>(user.UserProperties);
model.Add(new UserHelperModel
{
Type = UserType.LocalUser,
Username = user.UserName,
UserAlias = props.UserAlias,
EmailAddress = props.EmailAddress,
Permissions = (Permissions)user.Permissions,
Features = (Features)user.Features
});
}
model.AddRange(filteredPlex.Select(user => new UserHelperModel
{
Type = UserType.PlexUser,
Username = user.Username,
UserAlias = user.UserAlias,
EmailAddress = user.EmailAddress,
Permissions = (Permissions)user.Permissions,
Features = (Features)user.Features
}));
model.AddRange(filteredEmby.Select(user => new UserHelperModel
{
Type = UserType.EmbyUser,
Username = user.Username,
UserAlias = user.UserAlias,
EmailAddress = user.EmailAddress,
Permissions = (Permissions)user.Permissions,
Features = (Features)user.Features
}));
return(model);
}
public async Task <RequestedModel> CheckRequestAsync(string musicId)
{
var blobs = await Repo.GetAllAsync().ConfigureAwait(false);
var blob = blobs.FirstOrDefault(x => x.MusicId == musicId);
if (blob == null)
{
return(null);
}
var model = ByteConverterHelper.ReturnObject <RequestedModel>(blob.Content);
model.Id = blob.Id;
return(model);
}
public IUserIdentity GetUserFromIdentifier(Guid identifier, NancyContext context)
{
var user = Repo.Get(identifier.ToString());
if (user == null)
{
return(null);
}
return(new UserIdentity
{
UserName = user.UserName,
Claims = ByteConverterHelper.ReturnObject <string[]>(user.Claims)
});
}
private Response UpdateUser()
{
var body = Request.Body.AsString();
if (string.IsNullOrEmpty(body))
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Could not save user, invalid JSON body"
}));
}
var model = JsonConvert.DeserializeObject <UserManagementUpdateModel>(body);
if (string.IsNullOrWhiteSpace(model.Id))
{
return(Response.AsJson(new JsonResponseModel
{
Result = true,
Message = "Couldn't find the user"
}));
}
var claims = new List <string>();
foreach (var c in model.Claims)
{
if (c.Selected)
{
claims.Add(c.Name);
}
}
var userFound = UserMapper.GetUser(new Guid(model.Id));
userFound.Claims = ByteConverterHelper.ReturnBytes(claims.ToArray());
var currentProps = ByteConverterHelper.ReturnObject <UserProperties>(userFound.UserProperties);
currentProps.UserAlias = model.Alias;
currentProps.EmailAddress = model.EmailAddress;
userFound.UserProperties = ByteConverterHelper.ReturnBytes(currentProps);
var user = UserMapper.EditUser(userFound);
var dbUser = UserLoginsRepo.GetAll().FirstOrDefault(x => x.UserId == user.UserGuid);
var retUser = MapLocalUser(user, dbUser?.LastLoggedIn ?? DateTime.MinValue);
return(Response.AsJson(retUser));
}
