/// <summary>
/// Tries to attach the given siren to the vehicle, replacing any existing siren.
/// </summary>
/// <param name="aVehicle">The vehicle.</param>
/// <param name="aSiren">The siren.</param>
/// <param name="anInitialState">The initial siren state.</param>
/// <param name="aPlayer">The calling player.</param>
private void AttachSirens(BaseVehicle aVehicle, Siren aSiren, SirenController.States anInitialState, IPlayer aPlayer = null)
{
DetachSirens(aVehicle);
SirenController theController = CreateSirenController(aVehicle, aSiren);
if (aVehicle as ModularCar)
{
if (aSiren.Modules == null)
{
Message(aPlayer, I18N_NOT_SUPPORTED, aSiren.Name, KEY_MODULAR_CAR);
DetachSirens(aVehicle);
return;
}
foreach (BaseVehicleModule eachModule in aVehicle.GetComponentsInChildren <BaseVehicleModule>())
{
SpawnAttachments(aSiren.Modules, aPlayer, theController, eachModule);
}
}
else if (!SpawnAttachments(aSiren.Vehicles, aPlayer, theController, aVehicle))
{
Message(aPlayer, I18N_NOT_SUPPORTED, aSiren.Name, aVehicle.PrefabName);
DetachSirens(aVehicle);
return;
}
theController.SetState(anInitialState);
}
public Siren Write(IEnumerable <OrderItemViewModel> data, Uri uri)
{
var sirenDoc = new Siren
{
@class = new[] { "collection" },
entities = new List <Entity>()
};
foreach (var order in data)
{
var entity = new Entity
{
@class = new[] { "order-item" },
rel = new[] { uri.Scheme + "://" + uri.DnsSafeHost + ":" +
(uri.Port != 80 ? uri.Port.ToString() : "") + "/rels/orderitem" },
href = uri.ToString(),
properties = order
};
sirenDoc.entities.Add(entity);
}
sirenDoc.links = new List <Link> {
new Link {
href = uri.ToString(), rel = new[] { "self" }
}, new Link {
href = uri.ToString().Replace("/items", ""), rel = new [] { "order" }
}
};
return(sirenDoc);
}
public Siren Write(Order data, Uri uri)
{
var sirenDoc = new Siren
{
@class = new [] { "order" },
properties = data,
entities =
new List <Entity>
{
new Entity
{
@class = new[] { "collection" },
rel =
new[]
{
uri.Scheme + "://" + uri.DnsSafeHost + ":" +
(uri.Port != 80 ? uri.Port.ToString() : "") + "/rels/order-items"
},
href = uri + "/items"
}
},
actions =
new List <Action> (new []
{
new Action
{
name = "delete-order",
title = "Delete Order",
href = uri.ToString(),
method = "DELETE"
},
new Action
{
name = "add-to-order",
title = "Add Item To Order",
method = "POST",
href = uri.ToString(),
type = "application/json",
fields =
new List <Field>(new[]
{
new Field {
name = "productCode", type = "text"
},
new Field {
name = "quantity", type = "number"
}
})
}
})
};
sirenDoc.links = new List <Link> (new [] { new Link {
rel = new [] { "self" }, href = uri.ToString()
} });
return(sirenDoc);
}
/// <summary>
/// Creates a new siren with default values
/// </summary>
/// <returns></returns>
internal Siren Create()
{
Siren siren = new Siren
{
Start = DateTime.Now
};
return(siren);
}
private void AttachAllCarSirens(IPlayer aPlayer, string aCommand, string[] someArgs)
{
Siren theSiren = someArgs.Length > 0 ? FindSirenForName(someArgs[0], aPlayer) : SirenDictionary.Values.First();
foreach (BaseVehicle eachVehicle in BaseNetworkable.serverEntities.OfType <BaseVehicle>())
{
AttachSirens(eachVehicle, theSiren, config.DefaultState, aPlayer);
}
Message(aPlayer, I18N_ATTACHED_GLOBAL, theSiren.Name);
}
// Update is called once per frame
void Update()
{
if (Target.gameObject.GetComponent <Move>().Size >= 4f)
{
Siren.Play();
nv.SetDestination(Target.position);
}
else
{
Siren.Pause();
}
}
protected override void LoadConfig()
{
base.LoadConfig();
try
{
config = Config.ReadObject <Configuration>();
if (config == null)
{
throw new JsonException();
}
try
{
foreach (string eachSirenFile in Interface.Oxide.DataFileSystem.GetFiles(DATAPATH_SIRENS, "*.json"))
{
string theFilename = eachSirenFile.Basename(".json");
try
{
Siren theSiren = Interface.Oxide.DataFileSystem.ReadObject <Siren>(DATAPATH_SIRENS + theFilename);
SirenDictionary.Add(theSiren.Name, theSiren);
}
catch
{
PrintWarning($"Siren file {theFilename}.json is invalid; ignoring");
}
}
}
catch
{
}
Puts("Loaded sirens: " + string.Join(", ", SirenDictionary.Keys));
if (SirenDictionary.IsEmpty())
{
PrintWarning("Configuration appears to be missing sirens; using defaults");
SirenDictionary.Add(SIREN_DEFAULT.Name, SIREN_DEFAULT);
SirenDictionary.Add(SIREN_SILENT.Name, SIREN_SILENT);
SaveConfig();
}
if (!config.ToDictionary().Keys.SequenceEqual(Config.ToDictionary(x => x.Key, x => x.Value).Keys))
{
PrintWarning("Configuration appears to be outdated; updating and saving");
SaveConfig();
}
}
catch
{
PrintWarning($"Configuration file {Name}.json is invalid; using defaults");
LoadDefaultConfig();
}
}
public Siren Write(IEnumerable <Order> data, Uri uri)
{
var sirenDoc = new Siren
{
@class = new [] { "collection" },
entities = new List <Entity> (),
properties = new { Count = data.Count() }
};
foreach (var order in data)
{
var entity = new Entity
{
@class = new [] { "order" },
rel = new [] { "item" },
properties = order,
links = new List <Link> {
new Link {
href = uri + "/" + order.OrderNumber, rel = new [] { "self" }
}
}
};
sirenDoc.entities.Add(entity);
}
sirenDoc.actions = new List <Action> (new [] {
new Action
{
name = "add-order",
title = "Add Order",
method = "POST",
href = uri.ToString(),
type = "application/json",
fields = new List <Field>(new[] { new Field {
name = "productCode", type = "text"
}, new Field {
name = "quantity", type = "number"
} })
}
});
sirenDoc.links = new List <Link> {
new Link {
href = uri.ToString(), rel = new [] { "self" }
}
};
return(sirenDoc);
}
private Siren Generate(IEnumerable <Actor> actors, Uri uri)
{
var doc = new Siren
{
@class = new [] { "collection" },
entities = new List <Entity> (),
properties = new { Count = actors.Count() }
};
foreach (var actor in actors)
{
var entity = new Entity
{
@class = new [] { nameof(Actor) },
rel = new [] { "item" },
properties = actor,
links = new List <Link> {
new Link {
href = uri + "/" + actor.Id, rel = new [] { "self" }
}
}
};
doc.entities.Add(entity);
}
doc.actions = new List <Action> (new [] {
new Action
{
name = "create-actor",
title = "Create Actor",
method = "POST",
href = uri.ToString(),
type = "application/json",
fields = new List <Field>(new[] { new Field {
name = "name", type = "text"
}, new Field {
name = "age", type = "number"
} })
}
});
doc.links = new List <Link> {
new Link {
href = uri.ToString(), rel = new [] { "self" }
}
};
return(doc);
}
/// <summary>
/// Saves a new siren.
/// </summary>
/// <param name="siren"></param>
/// <returns></returns>
internal Siren Save(Siren siren)
{
// Read in the existing sirens
var sirens = this.Retrieve();
// Assign a new Id
var maxId = sirens.Max(s => s.ID);
siren.ID = maxId + 1;
sirens.Add(siren);
WriteData(sirens);
return(siren);
}
/// <summary>
/// Creates or replaces the SirenController of the given vehicle.
/// </summary>
/// <param name="aVehicle">The vehicle.</param>
/// <param name="aSiren">The Siren.</param>
/// <param name="someNetIDs">Already existing siren entities.</param>
/// <returns>The newly created SirenController.</returns>
private SirenController CreateSirenController(BaseVehicle aVehicle, Siren aSiren, IEnumerable <uint> someNetIDs = null)
{
SirenController theController = aVehicle.GetComponent <SirenController>();
if (theController)
{
UnityEngine.Object.DestroyImmediate(theController);
}
theController = aVehicle.gameObject.AddComponent <SirenController>();
theController.Config = config;
theController.Siren = aSiren;
if (someNetIDs != null)
{
theController.NetIDs.UnionWith(someNetIDs);
}
return(theController);
}
private void AttachCarSirens(IPlayer aPlayer, string aCommand, string[] someArgs)
{
if (aPlayer.IsServer)
{
Message(aPlayer, I18N_PLAYERS_ONLY, aCommand);
return;
}
BaseVehicle theVehicle = RaycastVehicle(aPlayer);
if (theVehicle)
{
Siren theSiren = someArgs.Length > 0 ? FindSirenForName(someArgs[0], aPlayer) : SirenDictionary.Values.First();
AttachSirens(theVehicle, theSiren, config.DefaultState, aPlayer);
Message(aPlayer, I18N_ATTACHED, theSiren.Name);
}
}
public Siren Write(SiteDetail data, Uri uri)
{
var sirenDoc = new Siren
{
@class = new [] { "siteDetail" },
properties = data
};
sirenDoc.links = new List <Link>()
{
new Link {
rel = new [] { "self" }, href = uri.ToString()
},
new Link {
rel = new [] { "orders", "collection" }, href = uri + "orders"
}
};
return(sirenDoc);
}
public async Task <IActionResult> PostSiren([FromBody] SirenForInsertDto sirenDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Siren siren = _mapper.Map <Siren>(sirenDto);
try
{
await _context.insertSirenAsync(siren);
}catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(StatusCode(500, "Erreur lors de l'ajout du Siren"));
}
return(CreatedAtAction("GetSiren", new { id = siren.Id }, siren));
}
/// <summary>
/// Updates an existing siren
/// </summary>
/// <param name="id"></param>
/// <param name="siren"></param>
/// <returns></returns>
internal Siren Save(int id, Siren siren)
{
// Read in the existing sirens
var sirens = this.Retrieve();
// Locate and replace the item
var itemIndex = sirens.FindIndex(s => s.ID == siren.ID);
if (itemIndex > 0)
{
sirens[itemIndex] = siren;
}
else
{
return(null);
}
WriteData(sirens);
return(siren);
}
public async Task <IActionResult> PutSiren([FromRoute] int id, [FromBody] SirenForUpdateDto siren)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != siren.Id)
{
return(BadRequest());
}
Siren sirenEntity = await _context.getSirenFromIdAsync(id);
if (sirenEntity == null)
{
return(NotFound());
}
_mapper.Map(siren, sirenEntity);
await _context.SaveAsync();
return(NoContent());
}
public Siren Write(Order data, Uri uri)
{
var sirenDoc = new Siren
{
@class = new [] { "order" },
properties = data,
entities =
new List <Entity>
{
new Entity
{
@class = new[] { "collection" },
rel =
new[]
{
uri.Scheme + "://" + uri.DnsSafeHost + ":" +
(uri.Port != 80 ? uri.Port.ToString() : "") + "/rels/order-items"
},
href = uri + "/items"
}
},
actions = new List <Action>()
};
if (data.Status == "Pending")
{
sirenDoc.actions.Add(new Action
{
name = "delete-order",
title = "Delete Order",
href = uri.ToString(),
method = "DELETE"
});
sirenDoc.actions.Add(new Action
{
name = "add-to-order",
title = "Add Item To Order",
method = "POST",
href = uri.ToString(),
type = "application/json",
fields =
new List <Field>(new[]
{
new Field {
name = "productCode", type = "text"
},
new Field {
name = "quantity", type = "number"
}
})
});
sirenDoc.actions.Add(new Action
{
name = "ship-order",
title = "Ship Order",
method = "POST",
href = uri + "/ship",
type = "application/json",
fields =
new List <Field>(new[]
{
new Field {
name = "name", type = "text"
},
new Field {
name = "address", type = "text"
}
})
});
}
else if (data.Status == "Shipped")
{
sirenDoc.actions.Add(new Action
{
name = "request-return",
title = "Request Return Of Order",
method = "POST",
href = uri + "/return",
type = "application/json",
fields = new List <Field>(new []
{
new Field {
name = "reason", type = "text"
}
})
});
}
if (sirenDoc.actions.Count == 0)
{
sirenDoc.actions = null;
}
sirenDoc.links = new List <Link> (new [] { new Link {
rel = new [] { "self" }, href = uri.ToString()
} });
return(sirenDoc);
}
public override int GetHashCode() => Siren.GetHashCode();
/// <summary>
/// Vérifie la validité d'un numéro SIRET (et de son numéro SIREN associé).
/// (Attention : cette méthode valide le numéro SIRET
/// selon l'algorithme de Luhn, mais ne vérifie pas
/// que le numéro soit attribué ni à quel établissement).
/// </summary>
/// <param name="siretToCheck">Numéro SIRET.</param>
/// <returns>Vrai si le SIRET, et son SIREN associé sont valides, faux sinon.</returns>
/// <remarks>Système d’Identification du Répertoire des ETablissements.
/// http://fr.wikipedia.org/wiki/SIRET
/// </remarks>
public static bool Check(string siretToCheck)
{
// Les numéros Siren et Siret doivent être valides tous les deux :
return(Luhn.Check(siretToCheck, LuhnCheckType.Siret) && Siren.Check(siretToCheck.Substring(0, 9)));
}
public async Task <int> insertSirenAsync(Siren siren)
{
await _context.Sirens.AddAsync(siren);
return(await SaveAsync());
}
public async Task <int> deleteSirenAsync(Siren siren)
{
_context.Sirens.Remove(siren);
return(await SaveAsync());
}
