private static bool Connect()
{
_connetions = new DataConnections
{
UserPass = _args.UserPassword
};
bool allConnected = true;
if (_args.PcPath != null && !_connetions.TrySetPcBase(_args.PcPath))
{
allConnected &= _connetions.TryCreateAndSetPcBase(_args.PcPath);
}
if (_args.PhonePath != null && !_connetions.TrySetPhoneBase(_args.PhonePath))
{
allConnected &= _connetions.TryCreateAndSetPhoneBase(_args.PhonePath);
}
if (_args.UsePsd)
{
allConnected &= ConnectPsd();
}
return(allConnected);
}
bool IDataPersistence.Persist(IPersistence persistence)
{
persistence.UpsertField(Constants.IDataPesistence_InitializeMode, InitializeMode.ToString());
persistence.UpsertField(Constants.IDataPesistence_PersistMode, PersistMode.ToString());
persistence.UpsertFieldArray(Constants.IDataPesistence_DataConnections, DataConnections.ToArray());
return(true);
}
protected void BtnDelete_Click1(object sender, EventArgs e)
{
SqlParameter[] sqlParams;
{
sqlParams = new SqlParameter[3];
sqlParams[0] = new SqlParameter("@FirstName", SqlDbType.VarChar, 40);
sqlParams[0].Value = TxtAddFName.Text.Trim();
sqlParams[1] = new SqlParameter("@LastName", SqlDbType.VarChar, 40);
sqlParams[1].Value = TxtAddLName.Text.Trim();
sqlParams[2] = new SqlParameter("@Email", SqlDbType.VarChar, 50);
sqlParams[2].Value = TxtAddEmail.Text.Trim();
}
DataConnections.RunSPReturnNone_PortalAdmin("spS_DeleteUser", sqlParams);
}
bool IDataPersistence.Retrieve(IPersistence persistence)
{
InitializeMode = (eInitializeMode)Enum.Parse(
typeof(eInitializeMode),
persistence.GetFieldValue(Constants.IDataPesistence_InitializeMode,
eInitializeMode.None.ToString()));
PersistMode = (ePersistMode)Enum.Parse(
typeof(ePersistMode),
persistence.GetFieldValue(Constants.IDataPesistence_PersistMode,
ePersistMode.Never.ToString()));
string[] connections = persistence.GetFieldValues(Constants.IDataPesistence_DataConnections, "");
DataConnections.Clear();
DataConnections.AddRange(connections);
return(true);
}
protected void BtnAdd_Click1(object sender, EventArgs e)
{
SqlParameter[] sqlParams;
{
sqlParams = new SqlParameter[5];
sqlParams[0] = new SqlParameter("@FirstName", SqlDbType.VarChar, 40);
sqlParams[0].Value = TxtAddFName.Text.Trim();
sqlParams[1] = new SqlParameter("@LastName", SqlDbType.VarChar, 40);
sqlParams[1].Value = TxtAddLName.Text.Trim();
sqlParams[2] = new SqlParameter("@Email", SqlDbType.VarChar, 50);
sqlParams[2].Value = TxtAddEmail.Text.Trim();
sqlParams[3] = new SqlParameter("@Password", SqlDbType.VarChar, 40);
sqlParams[3].Value = TxtAddPassword.Text.Trim();
sqlParams[4] = new SqlParameter("@IsActive", SqlDbType.Bit, 1);
sqlParams[4].Value = CheckBox1.Checked;
}
DataConnections.RunSPReturnNone_PortalAdmin("spS_InsertUser", sqlParams);
}
public PSDForm(DataConnections dataConnections)
{
InitializeComponent();
_connections = dataConnections;
}
/// <summary> /// Get the Data connection based on the id given /// </summary> /// <param name="id">The id of the connection</param> /// <returns>The data connection</returns> public DataConnection DataConnection(Guid id) => DataConnections.Where(item => item.Id == id).FirstOrDefault();
/// <summary>
/// Save a piece of information to the appropriate package element
/// </summary>
/// <typeparam name="T">The type of data to be saved</typeparam>
/// <param name="dataToSave">The data to be saved</param>
/// <returns>The saved data</returns>
public T Save <T>(T dataToSave) where T : CommonObject
{
// Get the type of data to be saved
String typeOfData = typeof(T).ToShortName();
// Based on the type of data, save it to the correct repository element
switch (typeOfData)
{
case "apidefinition":
// Get the actual value from the object wrapper
ApiDefinition apiDefinition = (ApiDefinition)Convert.ChangeType(dataToSave, typeof(ApiDefinition));
// If the type is not null
if (apiDefinition != null)
{
// Does this api definition already exist?
ApiDefinition existingApiDefinition =
(apiDefinition.Id == Guid.Empty) ? null : this.Api(apiDefinition.Id);
// No API Definition found?
if (existingApiDefinition == null)
{
// Doesn't exist currently so create a new Id
// and assign the object as the "existing" api definition
existingApiDefinition = apiDefinition;
existingApiDefinition.Id = Guid.NewGuid();
// Add this new api definition to the repository
ApiDefinitions.Add(existingApiDefinition);
}
else
{
// Assign the values from the item to save
existingApiDefinition.Description = apiDefinition.Description;
existingApiDefinition.Name = apiDefinition.Name;
existingApiDefinition.LastUpdated = DateTime.Now;
// Assign the foreign keys
existingApiDefinition.DataConnection = apiDefinition.DataConnection;
existingApiDefinition.DataDefinition = apiDefinition.DataDefinition;
existingApiDefinition.CredentialsLinks = apiDefinition.CredentialsLinks;
}
// Convert the data back to the return data type (which is actually the same)
dataToSave = (T)Convert.ChangeType(existingApiDefinition, typeof(T));
}
break;
case "dataitemdefinition":
// Get the actual value from the object wrapper
DataItemDefinition dataItemDefinition = (DataItemDefinition)Convert.ChangeType(dataToSave, typeof(DataItemDefinition));
// If the type is not null
if (dataItemDefinition != null)
{
// Does this data definition already exist?
DataItemDefinition existingDataItemDefinition =
(dataItemDefinition.Id == Guid.Empty) ? null : this.DataDefinition(dataItemDefinition.Id);
// No data definition found?
if (existingDataItemDefinition == null)
{
// Doesn't exist currently so create a new Id
// and assign the object as the "existing" data definition
existingDataItemDefinition = dataItemDefinition;
existingDataItemDefinition.Id = Guid.NewGuid();
// Add this new data definition to the repository
DataDefinitions.Add(existingDataItemDefinition);
}
else
{
// Assign the values from the item to save
existingDataItemDefinition.Description = dataItemDefinition.Description;
existingDataItemDefinition.Name = dataItemDefinition.Name;
existingDataItemDefinition.Culture = dataItemDefinition.Culture;
existingDataItemDefinition.EncodingFormat = dataItemDefinition.EncodingFormat;
existingDataItemDefinition.LastUpdated = DateTime.Now;
// Assign the lists
existingDataItemDefinition.ItemProperties = dataItemDefinition.ItemProperties;
existingDataItemDefinition.PropertyBag = dataItemDefinition.PropertyBag;
}
// Convert the data back to the return data type (which is actually the same)
dataToSave = (T)Convert.ChangeType(existingDataItemDefinition, typeof(T));
}
break;
case "dataconnection":
// Get the actual value from the object wrapper
DataConnection connection = (DataConnection)Convert.ChangeType(dataToSave, typeof(DataConnection));
// If the type is not null
if (connection != null)
{
// Does this connection already exist?
DataConnection existingConnection =
(connection.Id == Guid.Empty) ? null : DataConnection(connection.Id);
// No connection found?
if (existingConnection == null)
{
// Doesn't exist currently so create a new Id
// and assign the object as the "existing" connection
existingConnection = connection;
existingConnection.Id = Guid.NewGuid();
// Add this new connection to the repository
DataConnections.Add(existingConnection);
}
else
{
// Assign the values from the item to save
existingConnection.ConnectionString = connection.ConnectionString;
existingConnection.Description = connection.Description;
existingConnection.Name = connection.Name;
existingConnection.ProviderType = connection.ProviderType;
existingConnection.Credentials = connection.Credentials;
existingConnection.LastUpdated = DateTime.Now;
existingConnection.PropertyBag = connection.PropertyBag;
existingConnection.ObjectName = connection.ObjectName;
}
// Convert the data back to the return data type (which is actually the same)
dataToSave = (T)Convert.ChangeType(existingConnection, typeof(T));
}
break;
case "transformation":
// Get the actual value from the object wrapper
Transformation transformation = (Transformation)Convert.ChangeType(dataToSave, typeof(Transformation));
// If the type is not null
if (transformation != null)
{
// Does this transformation already exist?
Transformation existingTransformation =
(transformation.Id == Guid.Empty) ? null : Transformation(transformation.Id);
// No transformation found?
if (existingTransformation == null)
{
// Doesn't exist currently so create a new Id
// and assign the object as the "existing" transformation
existingTransformation = transformation;
existingTransformation.Id = Guid.NewGuid();
// Add this new transformation to the repository
Transformations.Add(existingTransformation);
}
else
{
// Assign the values from the item to save
existingTransformation.Description = transformation.Description;
existingTransformation.Name = transformation.Name;
existingTransformation.LastUpdated = DateTime.Now;
}
// Convert the data back to the return data type (which is actually the same)
dataToSave = (T)Convert.ChangeType(existingTransformation, typeof(T));
}
break;
case "credentials":
// Get the actual value from the object wrapper
Credentials credentials = (Credentials)Convert.ChangeType(dataToSave, typeof(Credentials));
// If the type is not null
if (credentials != null)
{
// Does this set of credentials already exist?
Credentials existingCredentials =
(credentials.Id == Guid.Empty) ? null : this.Credentials(credentials.Id);
// Loop the properties and see if any have not been saved before. If not give them an Id
credentials.Properties.ForEach(credential =>
{
if (credential.Id == null)
{
credential.Id = Guid.NewGuid();
}
});
// No credentials found?
if (existingCredentials == null)
{
// Doesn't exist currently so create a new Id
// and assign the object as the "existing" credentials
existingCredentials = credentials;
existingCredentials.Id = Guid.NewGuid();
// Add this new credentials to the repository
CredentialsStore.Add(existingCredentials);
}
else
{
// Assign the values from the item to save
existingCredentials.Description = credentials.Description;
existingCredentials.Name = credentials.Name;
existingCredentials.LastUpdated = DateTime.Now;
// Assign the lists
existingCredentials.Properties = credentials.Properties;
}
// Convert the data back to the return data type (which is actually the same)
dataToSave = (T)Convert.ChangeType(existingCredentials, typeof(T));
}
break;
}
// Make sure as the item is saved to this package that the
// reference to it is inside the object
dataToSave.ParentPackage = this;
// Return the data that was saved
return(dataToSave);
}
