public bool RegisterComputer(DataContracts.HostnameChanger msg)
{
var returnCode = ProcessHandler.Run("/bin/bash",
$"{Path.Combine(Settings.Location, "osxbind.sh")} {msg.ADDom} {msg.ADUser} {msg.ADPass} {msg.ADOU}");
return returnCode == 0;
}
public static int CreatePackage(DataContracts.Package newPackage)
{
Contract.Requires(newPackage != null);
Contract.Requires(GetPackageById(newPackage.Id) == null);
Contract.Ensures(GetPackageById(newPackage.Id) != null);
Contract.Ensures(GetPackageById(newPackage.Id).Equals(newPackage));
using (var db = new DatabaseContext())
{
var package = new Package
{
Name = newPackage.Name,
Description = newPackage.Description,
OwnerEmail = newPackage.OwnerEmail,
Owner = db.Users.Find(newPackage.OwnerEmail),
Memberships = new List<Membership>()
};
db.Packages.Add(package);
db.SaveChanges();
foreach (var id in newPackage.FileIds)
{
package.Memberships.Add(new Membership { PackageId = package.Id, FileId = id });
}
db.Entry(db.Packages.Find(package.Id)).State = EntityState.Modified;
db.SaveChanges();
return package.Id;
}
}
public static Return<DataContracts.ActivateUserData> Submit(DataContracts.ActivateUserData activateUserData)
{
if (activateUserData.IsValid())
return new Return<DataContracts.ActivateUserData>(io.Constants.SUCCESS, "", "", activateUserData);
else
return new Return<DataContracts.ActivateUserData>(io.Constants.FAILURE, "", "", activateUserData);
}
internal static io.Data.Return<DataContracts.ForgotPasswordData> ForgotPassword(DataContracts.ForgotPasswordData forgotPasswordData)
{
const string functionName = _className + ".ForgotPassword()";
if (!forgotPasswordData.IsValid())
return new io.Data.Return<DataContracts.ForgotPasswordData>(io.Constants.FAILURE, "Invalid Email", "", forgotPasswordData);
string where = "Email = '" + forgotPasswordData.Email.Value + "'";
using (var rows = new iocontacts.Databases.io_contacts.Tables.EntityContacts(where, string.Empty))
{
if (rows.QueryResult.Failed)
return new io.Data.Return<DataContracts.ForgotPasswordData>(io.Constants.SUCCESS, "", "", forgotPasswordData);
if (rows.Count == 0)
return new io.Data.Return<DataContracts.ForgotPasswordData>(io.Constants.SUCCESS, "", "", forgotPasswordData);
string guid = rows[0].UID;
rows[0].UID = Guid.NewGuid().ToString();
if (rows[0].UpdateRow().Success)
guid = rows[0].UID;
string rootSite = Common.SiteRoot();
Email.SendEmail(0, rows[0].Email, "Forgot Password", "Click " + rootSite + "/changepassword.aspx?t=" + guid + " to change password.");
return new io.Data.Return<DataContracts.ForgotPasswordData>(io.Constants.SUCCESS, "", "", forgotPasswordData);
}
}
public DataContracts.ICompany AddCompany(DataContracts.ICompany company)
{
Company newCompany = null;
using(var connection = new SqlConnection(base.ConnectionString))
{
connection.Open();
using( var command = new SqlCommand("sp_CompanyCreate", connection))
{
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.AddWithValue("@Name", company.Name);
command.Parameters.AddWithValue("@Address1", company.Address.Street1);
command.Parameters.AddWithValue("@Address2", company.Address.Street2);
command.Parameters.AddWithValue("@City", company.Address.City);
command.Parameters.AddWithValue("@StateId", company.Address.StateCode);
command.Parameters.AddWithValue("@Zip", company.Address.PostalCode);
command.Parameters.AddWithValue("@PhoneNumber", company.PhoneNumber);
connection.Open();
var dataReader = command.ExecuteReader();
//Get the newly created Company.
while (dataReader.Read())
{
newCompany = (Company)new CompanyAdapter().Resolve(new Company(), dataReader);
}
}
}
return newCompany;
}
public DataContracts.IProject AddProject(DataContracts.IProject project)
{
using (var connection = new SqlConnection(base.ConnectionString))
{
var adapter = new ProjectAdapter();
using (var command = new SqlCommand("sp_projectCreate", connection))
{
command.Parameters.AddRange(adapter.ResolveToParameters(project).ToArray());
command.CommandType = CommandType.StoredProcedure;
connection.Open();
var reader = command.ExecuteReader();
while (reader.Read())
{
project = (Project)adapter.Resolve(new Project(), reader);
}
connection.Close();
}
}
return project;
}
public bool UserRegistration(DataContracts.UserDetails userDetails)
{
StoredProcedureDataContext dbmlObject = new StoredProcedureDataContext();
dbmlObject.InsertUserDetails(userDetails.CompanyId, userDetails.FirstName, userDetails.LastName, userDetails.UserEmail, userDetails.IsOwner, userDetails.EncryptedPassword);
dbmlObject.SubmitChanges();
return true;
}
public void Update(DataContracts.Category entity)
{
Category cat = _source.First(o => o.ID == entity.ID);
if (cat != null)
{
cat.Libelle = entity.Libelle;
}
}
public void Update(DataContracts.UserProducts entity)
{
UserProducts up = _source.First(o => o.IdProduct == entity.IdProduct && o.IdUser == entity.IdUser);
if (up != null)
{
up.Quantity = entity.Quantity;
}
}
public void Update(DataContracts.Product entity)
{
string query = string.Format("UPDATE PRODUCT SET libelle='{0}', id_category={1} WHERE id={2};", entity.Libelle, entity.IdCategory, entity.ID);
using (SqlCommand cmd = AccessBD.Connection.CreateCommand())
{
cmd.CommandText = query;
cmd.ExecuteNonQuery();
}
}
public void Delete(DataContracts.Device entity)
{
string query = string.Format("DELETE FROM DEVICE WHERE id={0};", entity.ID);
using (SqlCommand cmd = AccessBD.Connection.CreateCommand())
{
cmd.CommandText = query;
cmd.ExecuteNonQuery();
}
}
public void Insert(DataContracts.Device entity)
{
string query = string.Format("INSERT INTO DEVICE(type, uniqueIdentifier, userId) VALUES('{0}', '{1}', '{2}');", entity.type, entity.uniqueIdentifier, entity.userId);
using (SqlCommand cmd = AccessBD.Connection.CreateCommand())
{
cmd.CommandText = query;
cmd.ExecuteNonQuery();
}
}
public void Delete(DataContracts.UserProducts entity)
{
string query = string.Format("DELETE FROM USERPRODUCTS WHERE id = {0};", entity.ID);
using (SqlCommand cmd = AccessBD.Connection.CreateCommand())
{
cmd.CommandText = query;
cmd.ExecuteNonQuery();
}
}
public void Update(DataContracts.Product entity)
{
Product prod = _source.First(o => o.ID == entity.ID);
if (prod != null)
{
prod.IdCategory = entity.IdCategory;
prod.Libelle = entity.Libelle;
}
}
public void Insert(DataContracts.UserProducts entity)
{
string query = string.Format("INSERT INTO USERPRODUCTS(idProduct, idUser, quantity) VALUES('{0}', '{1}', '{2}');", entity.IdProduct, entity.IdUser, entity.Quantity);
using (SqlCommand cmd = AccessBD.Connection.CreateCommand())
{
cmd.CommandText = query;
cmd.ExecuteNonQuery();
}
}
public void Insert(DataContracts.Product entity)
{
string query = string.Format("INSERT INTO PRODUCT(libelle, id_category, ean) VALUES('{0}',{1},'{2}');", entity.Libelle, entity.IdCategory, entity.Code);
using (SqlCommand cmd = AccessBD.Connection.CreateCommand())
{
cmd.CommandText = query;
cmd.ExecuteNonQuery();
}
}
public void Update(DataContracts.UserProducts entity)
{
string query = string.Format("UPDATE USERPRODUCTS SET idProduct = {0}, idUser = {1}, quantity = {2};", entity.IdUser, entity.IdUser, entity.Quantity);
using (SqlCommand cmd = AccessBD.Connection.CreateCommand())
{
cmd.CommandText = query;
cmd.ExecuteNonQuery();
}
}
public void Update(DataContracts.Device entity)
{
Device dev = _source.First(o => o.ID == entity.ID);
if (dev != null)
{
dev.type = entity.type;
dev.uniqueIdentifier = entity.uniqueIdentifier;
dev.userId = entity.userId;
}
}
public void Update(DataContracts.Recette entity)
{
Recette rec = _source.Find(o => o.ID == entity.ID);
if (rec != null)
{
rec.Ingrédients = entity.Ingrédients;
rec.Instructions = entity.Instructions;
rec.Nom = entity.Nom;
rec.Description = entity.Description;
}
}
internal static io.Data.Return<DataContracts.CredentialData> Login(DataContracts.CredentialData credentialData)
{
var functionName = "ioauth.Modules.Authentication.Authenticate.Login()";
if (!credentialData.IsValid())
return new io.Data.Return<DataContracts.CredentialData>(io.Constants.FAILURE, @"Invalid Login Id or Password", "", credentialData);
using (var users = new iocontacts.Databases.io_contacts.Views.DataContracts.Login.GetUser(credentialData.Email.Value))
{
if (users.QueryResult.Failed)
users.QueryResult.LogResult(1, 1, 1, 0, 101, functionName);
if (users.Count ==0)
return new io.Data.Return<DataContracts.CredentialData>(io.Constants.FAILURE, @"Invalid Login Id or Password", "", credentialData);
if (users[0].Password != GenerateHash(credentialData.Password.Value, users[0].EntityContactKey.ToString()))
return new io.Data.Return<DataContracts.CredentialData>(io.Constants.FAILURE, @"Invalid Login Id or Password", "", credentialData);
if (users[0].Active == false)
return new io.Data.Return<DataContracts.CredentialData>(io.Constants.FAILURE, @"Account not active", "", credentialData);
using (var sessions = new GetActiveSessions(credentialData.UserAgent.Value, users[0].EntityContactKey))
{
foreach (GetActiveSessions.ActiveSession session in sessions)
session.Active = false;
credentialData.FirstName.Value = users[0].FirstName;
credentialData.LastName.Value = users[0].LastName;
credentialData.Email.Value = users[0].Email;
GetActiveSessions.ActiveSession newSession = null;
newSession = sessions.NewActiveSession();
newSession.EntityContactKey = users[0].EntityContactKey;
newSession.Active = true;
newSession.LastActivity = DateTime.Now.ToString();
newSession.UserAgent = credentialData.UserAgent.Value.ToString();
io.Data.Return<bool> updateResult = sessions.Update();
if (updateResult.Failed)
return new io.Data.Return<DataContracts.CredentialData>(io.Constants.FAILURE, "Failed to create session", updateResult.Message, credentialData).LogResult(1, 1, 1, 0, 100, functionName);
var newSessions = Databases.io_auth.Tables.UserSessions.GetObjectWithKey(newSession.UserSessionKey);
if (newSessions.Failed)
return new io.Data.Return<DataContracts.CredentialData>(io.Constants.FAILURE, "Failed to create session", updateResult.Message, credentialData).LogResult(1, 1, 1, 0, 100, functionName);
credentialData.Token.Value = newSessions.Value.Token;
credentialData.Token.IsValid = true;
return new io.Data.Return<DataContracts.CredentialData>(io.Constants.SUCCESS, "", "", credentialData);
}
}
}
public static void CreateUser(DataContracts.User newUser)
{
Contract.Requires(newUser.Email != null);
Contract.Requires(GetUserByEmail(newUser.Email) == null);
Contract.Ensures(GetUserByEmail(newUser.Email).Equals(newUser));
using (var db = new DatabaseContext())
{
db.Users.Add((User)newUser);
db.SaveChanges();
}
}
/// <summary>
/// This method contains the core implementation for generating the GeneratedCode
/// instance.
/// </summary>
/// <remarks>
/// This method decorates every type found in codeNamespace with a CodeTypeMemberExtension.
/// And then it sends each type through series of ITypeFilters to figure out whether the type
/// is a service contract, service type, client type, message contract or data contract.
/// </remarks>
private void ParseAndFilterCodeNamespace()
{
ITypeFilter dataContractTypeFilter = new DataContractTypeFilter();
ITypeFilter messageContractTypeFilter = new MessageContractTypeFilter();
ITypeFilter serviceContractTypeFilter = new ServiceContractTypeFilter();
ITypeFilter clientTypeTypeFilter = new ClientTypeTypeFilter();
ITypeFilter serviceTypeTypeFilter = new ServiceTypeTypeFilter();
for (int i = 0; i < codeNamespace.Types.Count; i++)
{
// Take a reference to the current CodeTypeDeclaration.
CodeTypeDeclaration ctd = codeNamespace.Types[i];
// Create a new instance of CodeTypeMemberExtension to wrap
// the current CodeTypeDeclaration.
CodeTypeExtension typeExtension = new CodeTypeExtension(ctd);
// Also wrap the inner CodeTypeMember(s)
ExtendTypeMembers(typeExtension);
// Here we execute the type filters in the highest to lowest probability order.
if (dataContractTypeFilter.IsMatching(typeExtension))
{
typeExtension.Kind = CodeTypeKind.DataContract;
DataContracts.Add(typeExtension);
continue;
}
if (messageContractTypeFilter.IsMatching(typeExtension))
{
typeExtension.Kind = CodeTypeKind.MessageContract;
MessageContracts.Add(typeExtension);
continue;
}
if (serviceContractTypeFilter.IsMatching(typeExtension))
{
typeExtension.Kind = CodeTypeKind.ServiceContract;
ServiceContracts.Add(typeExtension);
continue;
}
if (clientTypeTypeFilter.IsMatching(typeExtension))
{
typeExtension.Kind = CodeTypeKind.ClientType;
ClientTypes.Add(typeExtension);
continue;
}
if (serviceTypeTypeFilter.IsMatching(typeExtension))
{
typeExtension.Kind = CodeTypeKind.ServiceType;
ServiceTypes.Add(typeExtension);
continue;
}
UnfilteredTypes.Add(typeExtension);
}
}
public Guid ConfigureComputationThread(DataContracts.SlaveConfig conf)
{
GlobalLogger.SendLogMessage("RoutingAiSlave", MessageFlags.Trivial, "Configuration Received:");
GlobalLogger.SendLogMessage("RoutingAiSlave", MessageFlags.Trivial, "Id = {0}", conf.OptimizationRequest.Id);
GlobalLogger.SendLogMessage("RoutingAiSlave", MessageFlags.Trivial, "ClientId = {0}", conf.OptimizationRequest.ClientId);
GlobalLogger.SendLogMessage("RoutingAiSlave", MessageFlags.Trivial, "RedisServers = {0}", String.Join<System.Net.IPEndPoint>(", ", conf.RedisServers));
GlobalLogger.SendLogMessage("RoutingAiSlave", MessageFlags.Trivial, "OsrmServers = {0}", String.Join<System.Net.IPEndPoint>(", ", conf.OSRMServers));
GlobalLogger.SendLogMessage("RoutingAiSlave", MessageFlags.Trivial, "RandomSeed = {0}", conf.RandomSeed);
GlobalLogger.SendLogMessage("RoutingAiSlave", MessageFlags.Trivial, "TaskCount = {0}", conf.OptimizationRequest.Tasks.Length);
GlobalLogger.SendLogMessage("RoutingAiSlave", MessageFlags.Trivial, "WorkerCount = {0}", conf.OptimizationRequest.Workers.Length);
return Guid.NewGuid();
}
public void Update(DataContracts.Device entity)
{
string query = string.Format("UPDATE DEVICE SET type='{1}', uniqueIdentifier='{2}', userId={3} WHERE id={0};",
entity.ID,
entity.type,
entity.uniqueIdentifier,
entity.userId);
using (SqlCommand cmd = AccessBD.Connection.CreateCommand())
{
cmd.CommandText = query;
cmd.ExecuteNonQuery();
}
}
internal static io.Data.Return<DataContracts.UpdatePasswordData> ChangePassword(UserSession userSession, DataContracts.UpdatePasswordData passwordData)
{
if (!passwordData.IsValid())
return new io.Data.Return<DataContracts.UpdatePasswordData>(io.Constants.FAILURE, "Invalid Password", "", passwordData);
if (passwordData.NewPassword.Value != passwordData.RepeatPassword.Value)
return new io.Data.Return<DataContracts.UpdatePasswordData>(io.Constants.FAILURE, "New Password must match", "", passwordData);
var updatePassword = iocontacts.Modules.Administration.EntityContact.SetPassword(userSession.UserSessionKey, userSession.EntityContactKey, passwordData.NewPassword.Value, passwordData.OldPassword.Value, true);
if (updatePassword.Failed)
return new io.Data.Return<DataContracts.UpdatePasswordData>(io.Constants.FAILURE, updatePassword.Message, "", passwordData);
return new io.Data.Return<DataContracts.UpdatePasswordData>(io.Constants.SUCCESS, updatePassword.Message, "", passwordData);
}
public DataContracts.ICompany UpdateCompany(DataContracts.ICompany company)
{
using(var connection = new SqlConnection(base.ConnectionString))
{
connection.Open();
using(var command = new SqlCommand("UPDATE COMPANY SET NAME = @Name, ADDRESS1 = @Address1, ADDRESS2 = @Address2, CITY = @City, STATEID = @StateID, ZIP = @Zip, PHONENUMBER = @PhoneNumber WHERE CompanyID = @CompanyID", connection))
{
command.Parameters.AddWithValue("@Name", company.Name);
command.Parameters.AddWithValue("@Address1", company.Address.Street1);
command.Parameters.AddWithValue("@Address2", company.Address.Street2);
command.Parameters.AddWithValue("@City", company.Address.City);
command.Parameters.AddWithValue("@StateId", company.Address.StateCode);
command.Parameters.AddWithValue("@Zip", company.Address.PostalCode);
command.Parameters.AddWithValue("@PhoneNumber", company.PhoneNumber);
command.Parameters.AddWithValue("@CompanyId", company.CompanyId);
command.ExecuteNonQuery();
connection.Close();
}
}
return company;
}
public DataContracts.IPerson AddPerson(DataContracts.IPerson person)
{
using (var connection = new SqlConnection(base.ConnectionString))
{
using (var command = new SqlCommand("sp_PersonCreate", connection))
{
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.AddWithValue("@firstName", person.FirstName);
command.Parameters.AddWithValue("@middleName", person.MiddleName);
command.Parameters.AddWithValue("@lastName", person.LastName);
connection.Open();
var dataReader = command.ExecuteReader();
while (dataReader.Read())
{
person = (Person)new PersonAdapter().Resolve(new Person(), dataReader);
}
}
}
return person;
}
private static XRefSpec GetXRefInfo(DataContracts.Common.ReferenceViewModel item, string key)
{
var result = new XRefSpec
{
Uid = item.Uid,
Name = item.Name,
Href = key,
CommentId = item.CommentId,
};
string name;
if (item.NameInDevLangs.TryGetValue("csharp", out name))
{
result["name.csharp"] = name;
}
if (item.NameInDevLangs.TryGetValue("vb", out name))
{
result["name.vb"] = name;
}
if (!string.IsNullOrEmpty(item.FullName))
{
result["fullName"] = item.FullName;
}
if (item.FullNameInDevLangs.TryGetValue("csharp", out name))
{
result["fullName.csharp"] = name;
}
if (item.FullNameInDevLangs.TryGetValue("vb", out name))
{
result["fullName.vb"] = name;
}
if (!string.IsNullOrEmpty(item.NameWithType))
{
result["nameWithType"] = item.NameWithType;
}
if (item.NameWithTypeInDevLangs.TryGetValue("csharp", out name))
{
result["nameWithType.csharp"] = name;
}
if (item.NameWithTypeInDevLangs.TryGetValue("vb", out name))
{
result["nameWithType.vb"] = name;
}
return result;
}
public bool TryGetDataContract(string typeName, out string contract)
{
return(DataContracts.TryGetValue(typeName, out contract));
}
private void RegisterDataContract(Type type)
{
var schema = JsonSchema.FromType(type).ToJson();
DataContracts.TryAdd(type.FullName, schema);
}
public void Update(DataContracts.Recette entity)
{
MyWebServices.RecetteService.Update(entity);
}
public void Insert(DataContracts.Recette entity)
{
MyWebServices.RecetteService.Insert(entity);
}
public void Delete(DataContracts.Recette entity)
{
MyWebServices.RecetteService.Delete(entity);
}
