public Manufacturer GetManufacturer(NameValueCollection appSettings, SnipeItApi snipe)
{
string manufacturer = GetOutputVariable("Win32_ComputerSystem.Manufacturer");
Manufacturer systemManufacturer = new Manufacturer(manufacturer);
return(systemManufacturer);
}
/// <summary>
/// Synchronizes the specified manufacturer details with an existing
/// <c>Snipt.It</c> manufacturer or creates one if no manufacturer exists.
/// </summary>
/// <param name="snipe">
/// The <see cref="SnipeItApi"/> instance used to access the <c>Snipt.It</c>
/// web API.
/// </param>
/// <param name="manufacturer">
/// The manufacturer name.
/// </param>
/// <returns>
/// The resulting <c>Snipt.It</c> <see cref="Manufacturer"/>.
/// </returns>
public static Manufacturer SyncManufacturer(this SnipeItApi snipe, string manufacturer)
{
// Validate parameters.
if (snipe == null)
{
throw new ArgumentNullException("snipe");
}
if (String.IsNullOrWhiteSpace(manufacturer))
{
throw new ArgumentNullException("manufacturer");
}
Manufacturer snipeManufacturer = snipe.ManufacturerManager.FindAll(new SearchFilter {
Search = manufacturer
})?.Rows.FirstOrDefault();
if (snipeManufacturer == null)
{
snipeManufacturer = new Manufacturer()
{
Name = manufacturer
};
var response = snipe.ManufacturerManager.Create(snipeManufacturer);
snipeManufacturer = snipe.ManufacturerManager.FindAll(new SearchFilter {
Search = manufacturer
})?.Rows.FirstOrDefault();
}
return(snipeManufacturer);
}
public Asset GetAsset(NameValueCollection appSettings, SnipeItApi snipe)
{
string systemName = GetOutputVariable("Win32_ComputerSystem.Name");
string serialNumber = GetOutputVariable("Win32_ComputerSystemProduct.IdentifyingNumber");
string macAddress = GetOutputVariable("Win32_NetworkAdapter.MACAddress");
Dictionary <string, string> customFields = new Dictionary <string, string>();
customFields.Add("_snipeit_mac_address_1", macAddress);
string warrantyMonths = appSettings["WarrantyMonths"];
bool isInteractive = false;
bool interactiveParseSuccess = Boolean.TryParse(appSettings["Interactive"], out isInteractive);
if (interactiveParseSuccess && isInteractive)
{
Console.WriteLine("Enter the computer name: ");
systemName = Console.ReadLine();
}
Asset currentComputer = new SnipeSharp.Endpoints.Models.Asset
{
Company = null,
AssetTag = appSettings["AssetTagPrefix"] + "-" + serialNumber, // <-- to be implemented.. somehow, somewhere
Model = null,
StatusLabel = null,
RtdLocation = null,
Name = systemName,
Serial = serialNumber,
WarrantyMonths = warrantyMonths,
CustomFields = customFields,
};
return(currentComputer);
}
/// <inheritdoc />
protected override void EndProcessing()
{
WriteWarning("This software is considered pre-alpha and is not ready for production use. Proceed with caution, and use at your own risk.");
var instance = new SnipeItApi {
Token = this.Token,
Uri = this.Uri
};
if (!SkipConnectionCheck)
{
if (!instance.TestConnection())
{
throw new ApiErrorException($"Could not validate a connection to Snipe-IT at Uri \"{Uri}\".");
}
}
if (Force && ApiHelper.HasApiInstance)
{
ApiHelper.Reset();
}
ApiHelper.Instance = instance;
ApiHelper.DisableLookupVerification = DisableLookupVerification;
if (PassThru)
{
WriteObject(ApiHelper.Instance);
}
}
public void CheckApiTokenAndUrl_NoUrlInApiSettings_ThrowException()
{
SnipeItApi snipe = new SnipeItApi();
snipe.ApiSettings.ApiToken = "xxxxx";
snipe.ReqManager.CheckApiTokenAndUrl();
}
/// <summary>
/// Synchronizes the specified model details with an existing
/// <c>Snipt.It</c> category or creates a new one if no category exists.
/// </summary>
/// <param name="snipe">
/// The <see cref="SnipeItApi"/> instance used to access the <c>Snipt.It</c>
/// web API.
/// </param>
/// <param name="categoryName">
/// The category name.
/// </param>
/// <param name="categoryType">
/// The category type.
/// </param>
/// <returns>
/// The resulting <c>Snipt.It</c> <see cref="Category"/>.
/// </returns>
public static Category SyncCategory(
this SnipeItApi snipe,
string categoryName,
string categoryType)
{
// Validate parameters.
if (snipe == null)
{
throw new ArgumentNullException("snipe");
}
if (String.IsNullOrWhiteSpace(categoryName))
{
throw new ArgumentNullException("assetCategory");
}
Category snipeCategory = snipe.CategoryManager.FindAll(new SearchFilter {
Search = categoryName
})?.Rows.FirstOrDefault();
if (snipeCategory == null)
{
snipeCategory = new Category()
{
Name = categoryName, Type = categoryType
};
var response = snipe.CategoryManager.Create(snipeCategory);
snipeCategory = snipe.CategoryManager.FindAll(new SearchFilter {
Search = categoryName
})?.Rows.FirstOrDefault();
}
return(snipeCategory);
}
public StatusLabel GetStatusLabel(NameValueCollection appSettings, SnipeItApi snipe)
{
string defaultLabel = appSettings["DefaultStatusLabel"];
StatusLabel defaultStatusLabel = new StatusLabel(defaultLabel);
return(defaultStatusLabel);
}
public void CheckApiTokenAndUrl_NoTokenInApiSettings_ThrowException()
{
SnipeItApi snipe = new SnipeItApi();
snipe.ApiSettings.BaseUrl = new Uri("http://google.com");
snipe.ReqManager.CheckApiTokenAndUrl();
}
public Company GetCompany(NameValueCollection appSettings, SnipeItApi snipe)
{
string companyName = appSettings["Company"];
Company currentCompany = new Company(companyName);
return(currentCompany);
}
/// <summary>
/// Synchronizes the specified system's details with the configured <c>Snipe.It</c>
/// system.
/// </summary>
private void SyncHostNameDetails(string hostName)
{
// Single Device.
SnipeItApi snipe =
SnipeApiExtensions.CreateClient(
snipeApiUrl,
snipeApiToken);
if (!String.IsNullOrWhiteSpace(hostName))
{
Log.Information($"Retrieving asset details for {hostName}");
try
{
var asset = AssetDescriptor.Create(hostName);
var components = ComponentDescriptor.Create(hostName);
try
{
Log.Information($"Synchronizing asset details for {hostName}");
// The current version of the SnipeSharp API has mapping issues causing the response not de serializing.
snipe.SyncAssetWithCompoments(asset, components);
}
catch (Exception ex)
{
Log.Error($"Failed to sync asset details for {hostName}");
Log.Error(ex.ToString());
}
}
catch (Exception ex)
{
Log.Error($"Failed to retrieve asset details for {hostName}");
Log.Error(ex.ToString());
}
}
}
public Location GetLocation(NameValueCollection appSettings, SnipeItApi snipe)
{
string assetLocation = this.Values["Location"];
Location currentLocation = new Location(assetLocation);
return(currentLocation);
}
public static void SyncAssetWithCompoments(
this SnipeItApi snipe,
AssetDescriptor assetDetails,
IEnumerable <ComponentDescriptor> components)
{
if (snipe == null)
{
throw new ArgumentNullException("snipe");
}
if (assetDetails == null)
{
throw new ArgumentNullException("assetDetails");
}
if (components == null)
{
throw new ArgumentNullException("components");
}
var snipeAsset = snipe.SyncAsset(assetDetails);
//// The Snipe API does not have the capability to check-out components.
//var snipeComponents = snipe.SyncComponents(components);
//foreach (var item in snipeComponents)
//{
// snipe.CheckOutComponent(snipeAsset.Serial, item.Serial);
//}
}
/// <summary>
/// Synchronizes the specified collection of <see cref="ComponentDescriptor"/>
/// details with a <c>Snipt.It</c> component or creates one if not asset matching
/// the specified serial exists.
/// </summary>
/// <param name="snipe">
/// The <see cref="SnipeItApi"/> instance used to access the <c>Snipt.It</c>
/// web API.
/// </param>
/// <param name="components">
/// The collection of <see cref="ComponentDescriptor"/>s describing the
/// components details.
/// </param>
/// <returns>
/// The resulting <c>Snipt.It</c> collection of <see cref="Component"/>s.
/// </returns>
public static IEnumerable <Component> SyncComponents(
this SnipeItApi snipe,
IEnumerable <ComponentDescriptor> components)
{
// Validate parameters.
if (snipe == null)
{
throw new ArgumentNullException("snipe");
}
if (components == null)
{
throw new ArgumentNullException("components");
}
List <Component> results = new List <Component>();
if (components.Any())
{
foreach (var item in components)
{
results.Add(snipe.SyncComponent(item));
}
}
return(results);
}
public static void syncAsset(SnipeItApi snipe, SnipeSharp.Endpoints.Models.Asset currentAsset)
{
try
{
SnipeSharp.Endpoints.SearchFilters.SearchFilter assetFilter = new SnipeSharp.Endpoints.SearchFilters.SearchFilter()
{
Search = currentAsset.AssetTag
};
SnipeSharp.Endpoints.Models.Asset foundAsset = snipe.AssetManager.FindOne(assetFilter);
if (foundAsset != null && foundAsset.AssetTag == currentAsset.AssetTag)
{
Trace.WriteLine("Asset already exists in db. Not added.");
}
else
{
var response = snipe.AssetManager.Create(currentAsset);
Trace.WriteLine("Response recieved from SnipeIT server after attempting to add asset: ");
Trace.WriteLine(response);
}
} catch (Exception e)
{
Trace.WriteLine("Exception encountered while adding asset: " + e.ToString());
}
}
/// <summary>
/// Synchronizes the specified system's details with the configured <c>Snipe.It</c>
/// system.
/// </summary>
private void SyncHostNameDetails(string hostName)
{
// Single Device.
SnipeItApi snipe =
SnipeApiExtensions.CreateClient(
ConfigurationManager.AppSettings["Snipe:ApiAddress"],
ConfigurationManager.AppSettings["Snipe:ApiToken"]);
if (!String.IsNullOrWhiteSpace(hostName))
{
Console.WriteLine($"Retrieving asset details for {hostName}");
try
{
var asset = AssetDescriptor.Create(hostName);
var components = ComponentDescriptor.Create(hostName);
try
{
Console.WriteLine($"Synchronizing asset details for {hostName}");
// The current version of the SnipeSharp API has mapping issues causing the response not de serializing.
snipe.SyncAssetWithCompoments(asset, components);
}
catch (Exception ex)
{
Console.WriteLine($"Failed to sync asset details for {hostName}");
}
}
catch (Exception ex)
{
Console.WriteLine($"Failed to retrieve asset details for {hostName}");
}
}
}
public void Init_MissingToken_ThrowsException()
{
Assert.Throws <NullApiTokenException>(() => {
var snipe = new SnipeItApi();
snipe.Uri = TEST_URI;
snipe.RequestManager.SetTokenAndUri();
});
}
public void Init_MissingURI_ThrowsException()
{
Assert.Throws <NullApiUriException>(() => {
var snipe = new SnipeItApi();
snipe.Token = TEST_TOKEN;
snipe.RequestManager.SetTokenAndUri();
});
}
/// <param name="api">The Api to grab the RequestManager from.</param>
/// <exception cref="SnipeSharp.Exceptions.MissingRequiredAttributeException">When the type parameter does not have the <see cref="PathSegmentAttribute">PathSegmentAttribute</see> attribute.</exception>
internal EndPoint(SnipeItApi api)
{
Api = api;
EndPointInfo = typeof(T).GetCustomAttribute <PathSegmentAttribute>();
if (null == EndPointInfo)
{
throw new MissingRequiredAttributeException(nameof(PathSegmentAttribute), typeof(T).Name);
}
}
public static SnipeItApi GetAPI()
{
ReadValues();
SnipeItApi API = new SnipeItApi();
API.ApiSettings.ApiToken = Token;
API.ApiSettings.BaseUrl = new Uri(URI);
return(API);
}
public static Asset Data(string Name)
{
SnipeItApi Snipe = Api.GetAPI();
SearchFilter Search = new SearchFilter
{
Search = Name
};
return(Snipe.AssetManager.FindOne(Search));
}
public void Init_NoneMissing_NotThrowsException()
{
var snipe = new SnipeItApi
{
Token = TEST_TOKEN,
Uri = TEST_URI
};
snipe.RequestManager.SetTokenAndUri();
Assert.True(true);
}
private static string Create(string companyname)
{
SnipeItApi Snipe = Api.GetAPI();
Company Comp = new Company
{
Name = companyname,
};
Snipe.CompanyManager.Create(Comp);
Name = Snipe.CompanyManager.Get(companyname).Name;
return(Name);
}
/// <summary>
/// Synchronizes the specified <see cref="AssetDescriptor"/> details with a
/// <c>Snipt.It</c> asset or creates one if not asset matching the specified
/// serial exists.
/// </summary>
/// <param name="snipe">
/// The <see cref="SnipeItApi"/> instance used to access the <c>Snipt.It</c>
/// web API.
/// </param>
/// <param name="assetDetails">
/// The <see cref="AssetDescriptor"/> describing the asset's details.
/// </param>
/// <returns>
/// The resulting <c>Snipt.It</c> <see cref="Asset"/>.
/// </returns>
public static Asset SyncAsset(this SnipeItApi snipe, AssetDescriptor assetDetails)
{
// Validate parameters.
if (snipe == null)
{
throw new ArgumentNullException("snipe");
}
if (assetDetails == null)
{
throw new ArgumentNullException("assetDetails");
}
Asset snipeAsset = snipe.AssetManager.FindOne(new SearchFilter {
Search = assetDetails.Serial
});
var manufacturer = SnipeApiExtensions.SyncManufacturer(snipe, assetDetails.Manufacturer);
string snipeCategory = SnipeApiExtensions.DefaultSnipeCategoriesMap[assetDetails.Category];
var category = SnipeApiExtensions.SyncCategory(snipe, snipeCategory, "asset");
var model = SnipeApiExtensions.SyncModel(snipe, manufacturer, category, assetDetails.Model, assetDetails.ModelNumber);
if (snipeAsset == null)
{
snipeAsset =
new Asset()
{
Name = assetDetails.Name,
ModelNumber = assetDetails.ModelNumber,
Manufacturer = manufacturer,
Category = category,
Model = model
};
var response = snipe.AssetManager.Create(snipeAsset);
snipeAsset = snipe.AssetManager.FindOne(new SearchFilter {
Search = assetDetails.Serial
});
}
else
{
snipeAsset.Name = assetDetails.Name;
snipeAsset.ModelNumber = assetDetails.ModelNumber;
snipeAsset.Manufacturer = manufacturer;
snipeAsset.Category = category;
snipeAsset.Model = model;
var response = snipe.AssetManager.Update(snipeAsset);
}
return(snipeAsset);
}
private static string Create(string DeviceCategory)
{
string category = DeviceCategory;
SnipeItApi Snipe = Api.GetAPI();
Category Cat = new Category
{
Name = category,
Type = "asset"
};
Snipe.CategoryManager.Create(Cat);
Name = Snipe.CategoryManager.Get(category).Name;
return(Name);
}
private static string Create(string DeviceMake, string DeviceModel, string ModelName)
{
SnipeItApi Snipe = Api.GetAPI();
Model assetmodel = new Model
{
Name = ModelName,
Manufacturer = Snipe.ManufacturerManager.Get(DeviceMake),
Category = Snipe.CategoryManager.Get("Laptops"),
ModelNumber = DeviceModel
};
Snipe.ModelManager.Create(assetmodel);
Name = Snipe.ModelManager.Get(ModelName).Name;
return(Name);
}
private static string Create(string DeviceMake)
{
string Make = DeviceMake;
SnipeItApi Snipe = Api.GetAPI();
Manufacturer maker = new Manufacturer
{
Name = Make
};
Snipe.ManufacturerManager.Create(maker);
Name = Snipe.ManufacturerManager.Get(Make).Name;
return(Name);
}
public void CheckApiTokenAndUrl_SetHttpClientBaseAddress_SetCorrectly()
{
SnipeItApi snipe = new SnipeItApi();
Uri url = new Uri("http://google.com");
snipe.ApiSettings.ApiToken = "xxxxx";
snipe.ApiSettings.BaseUrl = url;
snipe.ReqManager.CheckApiTokenAndUrl();
// Get the Static property value
Type type = typeof(RequestManager);
FieldInfo prop = type.GetField("Client", BindingFlags.NonPublic | BindingFlags.Static);
HttpClient value = prop.GetValue(snipe.ReqManager) as HttpClient;
Assert.AreEqual(url, value.BaseAddress);
}
/// <summary>
/// Synchronizes the specified model details with an existing
/// <c>Snipt.It</c> model or creates a new one if no model exists.
/// </summary>
/// <param name="snipe">
/// The <see cref="SnipeItApi"/> instance used to access the <c>Snipt.It</c>
/// web API.
/// </param>
/// <param name="manufacturer">
/// The <c>Snipt.It</c> <see cref="Manufacturer"/> that should be associated
/// with the specified model.
/// </param>
/// <param name="category">
/// The <c>Snipt.It</c> <see cref="Category"/> that should be associated
/// with the specified model.
/// </param>
/// <param name="modelName">
/// The model name.
/// </param>
/// <param name="modelNumber">
/// The model number.
/// </param>
/// <returns>
/// The resulting <c>Snipt.It</c> <see cref="Model"/>.
/// </returns>
public static Model SyncModel(
this SnipeItApi snipe,
Manufacturer manufacturer,
Category category,
string modelName,
string modelNumber)
{
// Validate parameters.
if (snipe == null)
{
throw new ArgumentNullException("snipe");
}
if (manufacturer == null)
{
throw new ArgumentNullException("manufacturer");
}
if (category == null)
{
throw new ArgumentNullException("category");
}
if (String.IsNullOrWhiteSpace(modelName))
{
throw new ArgumentNullException("modelName");
}
if (String.IsNullOrWhiteSpace(modelNumber))
{
throw new ArgumentNullException("modelNumber");
}
Model snipeModel = snipe.ModelManager.FindAll(new SearchFilter {
Search = modelName
}).Rows.FirstOrDefault();
if (snipeModel == null)
{
snipeModel = new Model()
{
Name = modelName, ModelNumber = modelNumber, Manufacturer = manufacturer, Category = category
};
var response = snipe.ModelManager.Create(snipeModel);
snipeModel = snipe.ModelManager.FindAll(new SearchFilter {
Search = modelName
}).Rows.FirstOrDefault();
}
return(snipeModel);
}
public Category GetCategory(NameValueCollection appSettings, SnipeItApi snipe)
{
string systemType = GetOutputVariable("Win32_ComputerSystem.PCSystemType");
// TODO: Place in a separate enum class:
WindowsSystemTypes winTypes = new WindowsSystemTypes();
string systemTypeFull = "Undefined";
try
{
systemTypeFull = winTypes.SystemTypes[systemType];
}
catch (Exception e)
{
Trace.WriteLine("Exception encountered while processing WinSystemType: " + e.ToString());
}
Category currentCategory = new Category(systemTypeFull);
return currentCategory;
}
public void CheckApiTokenAndUrl_SetAuthorizationHeader_SetCorrectly()
{
SnipeItApi snipe = new SnipeItApi();
Uri url = new Uri("http://google.com");
snipe.ApiSettings.ApiToken = "xxxxx";
snipe.ApiSettings.BaseUrl = url;
snipe.ReqManager.CheckApiTokenAndUrl();
// Get the Static property value
Type type = typeof(RequestManager);
FieldInfo prop = type.GetField("Client", BindingFlags.NonPublic | BindingFlags.Static);
HttpClient value = prop.GetValue(snipe.ReqManager) as HttpClient;
Assert.IsTrue(value.DefaultRequestHeaders.Authorization.Scheme == "Bearer" &&
value.DefaultRequestHeaders.Authorization.Parameter == "xxxxx");
}
