· 8 years ago · Jun 22, 2018, 07:50 PM
1Add-Type -Path "Oracle.DataAccess.dll"
2
3
4Function Get-TimeStamp {
5 return (Get-Date).ToString("yyyy/MM/dd HH:mm:ss.fff")
6} # Get-TimeStamp
7
8
9Function Get-ParameterValue ($errorString, $startDelimeter, $endDelimeter) {
10 $paramValueStart = $errorString.IndexOf($startDelimeter) + $startDelimeter.Length
11
12 if ($paramValueStart -lt $startDelimiter.Length) {
13 throw ("Error in Get-ParameterValue: " + $startDelimeter + " not found in error string.")
14 }
15
16 if ($endDelimeter -ne $null) {
17 $paramValueLength = $errorString.IndexOf($endDelimeter, $paramValueStart) - $paramValueStart
18 }
19 else {
20 $paramValueLength = $errorString.Length - $paramValueStart
21 }
22
23 return $errorString.SubString($paramValueStart, $paramValueLength)
24} # Get-ParameterValue
25
26
27Function Get-DbConnection ($udlFileName) {
28 try {
29 # Read each line of the UDL file into an array.
30 $udlArray = Get-Content $udlFilename -ErrorAction "Stop"
31
32 # Make sure the UDL file wasn't empty. Additionally, since the third line of the UDL
33 # file should contain the connection string, make sure the third item in $udlArray
34 # isn't null.
35 if (($udlArray -eq $null) -or ($udlArray[2] -eq $null)) {
36 throw ("Could not find connection string in $udlFilename.")
37 }
38
39 # The third line of the UDL file should be the connection string for the DB, so set the
40 # $dbConn connection string to the third item in $udlArray.
41 $fullConnectionString = $udlArray[2]
42
43 $provider = Get-ParameterValue $fullConnectionString "Provider=" ";"
44
45 if ($provider -like "*SQLOLEDB*") {$dbConn = New-Object System.Data.SqlClient.SqlConnection}
46 elseif ($provider -like "*Ora*") {$dbConn = New-Object Oracle.DataAccess.Client.OracleConnection}
47 else {throw "Invalid provider specified in $udlFileName. Please use a SQL Server OLE DB or Oracle OLE DB provider."}
48
49 # Remove the Provider section from the connection string.
50 $dbConn.ConnectionString = $fullConnectionString.Replace("Provider=" + $provider + ";", "")
51 }
52 catch {
53 throw ("Error in Get-DbConnection: " + $error[0])
54 }
55
56 return $dbConn
57} # Get-DbConnection
58
59
60Function ConvertTo-OracleCommand ($sqlCommand) {
61 $oraCommand = New-Object Oracle.DataAccess.Client.OracleCommand
62 $oraCommand.CommandText = $sqlCommand.CommandText
63
64 $sqlCommand.Parameters | ForEach-Object {
65 $sqlParam = $_
66 $oraParam = New-Object Oracle.DataAccess.Client.OracleParameter
67
68 $oraParam.ParameterName = $sqlParam.ParameterName.Replace("@", ":")
69 $oraParam.DbType = $sqlParam.DbType
70 $oraParam.Value = $sqlParam.Value
71
72 $oraCommand.Parameters.Add($oraParam) | Out-Null
73
74 $oraCommand.CommandText = $oraCommand.CommandText.Replace($sqlParam.ParameterName, $oraParam.ParameterName)
75 }
76
77 $oraCommand.CommandText = $oraCommand.CommandText.Replace("(nolock)", "")
78
79 if ($oraCommand.CommandText -match "select top \d+ ") {
80 $rowCount = Get-ParameterValue $oraCommand.CommandText "top " " "
81
82 $oraCommand.CommandText = $oraCommand.CommandText -replace "select top \d+ ","select "
83
84 $oraCommand.CommandText = "
85 select *
86 from ($($oraCommand.CommandText)) DerivedTable
87 where rownum <= $rowCount
88 "
89 }
90 elseif ($oraCommand.CommandText -match "select distinct top \d+ ") {
91 $rowCount = Get-ParameterValue $oraCommand.CommandText "top " " "
92
93 $oraCommand.CommandText = $oraCommand.CommandText -replace "select distinct top \d+ ","select distinct "
94
95 $oraCommand.CommandText = "
96 select *
97 from ($($oraCommand.CommandText)) DerivedTable
98 where rownum <= $rowCount
99 "
100 }
101
102 if ($oraCommand.CommandText -match "cast\(\w+\.\w+ as varbinary\(max\)\) <> cast\(\w+\.\w+ as varbinary\(max\)\)") {
103 $alias1 = Get-ParameterValue $oraCommand.CommandText "cast(" "."
104 $column1 = Get-ParameterValue $oraCommand.CommandText "cast($alias1." " as"
105 $alias2 = Get-ParameterValue $oraCommand.CommandText "<> cast(" "."
106 $column2 = Get-ParameterValue $oraCommand.CommandText "<> cast($alias2." " as"
107
108 $oraCommand.CommandText = $oraCommand.CommandText.Replace("cast($alias1.$column1 as varbinary(max)) <> cast($alias2.$column2 as varbinary(max))", "dbms_lob.compare($alias1.$column1, $alias2.$column2) <> 0")
109 }
110
111 if ($oraCommand.CommandText -match "\(updlock\)") {
112 $oraCommand.CommandText = $oraCommand.CommandText.Replace("(updlock)", "")
113 $oraCommand.CommandText += " for update"
114 }
115
116 if ($oraCommand.CommandText -match "with \(index = ") {
117 $index = Get-ParameterValue $oraCommand.CommandText "index = " ")"
118 $oraCommand.CommandText = $oraCommand.CommandText.Replace("with (index = $index)", "")
119 }
120
121 $oraCommand.BindByName = $true
122
123 return $oraCommand
124} # ConvertTo-OracleCommand
125
126
127# Note that the comparison order below is important. If the comparison was instead
128# ($value -eq [DBNull]::Value), and if $value was an empty string, PowerShell would
129# evaluate the comparison as true for some reason. With the order used below, it
130# correctly evaluates as false.
131Function ConvertTo-PsType ($value) {
132 try {
133 if ([DBNull]::Value -eq $value) {
134 return $null
135 }
136 elseif ($value.GetType().Name -eq "Decimal") {
137 if ($value.ToString().Contains(".")) {return [double]$value}
138 elseif ($value -lt [int]::MinValue -or $value -gt [int]::MaxValue) {return [long]$value}
139 else {return [int]$value}
140 }
141 else {
142 return $value
143 }
144 }
145 catch {
146 throw ("Error in ConvertTo-PsType: " + $error[0])
147 }
148} # ConvertTo-PsType
149
150
151Function ConvertTo-DbNull ($value) {
152 try {
153 if ($value -eq $null) {return [DBNull]::Value}
154 else {return $value}
155 }
156 catch {
157 throw ("Error in ConvertTo-DbNull: " + $error[0])
158 }
159} # ConvertTo-DbNull
160
161
162function Retry-Command
163{
164 param (
165 [Parameter(Mandatory=$true)][string]$command,
166 [Parameter(Mandatory=$true)][hashtable]$args,
167 [Parameter(Mandatory=$false)][int]$retries = 5,
168 [Parameter(Mandatory=$false)][int]$secondsDelay = 2
169 )
170
171 # Setting ErrorAction to Stop is important. This ensures any errors that occur in the command are
172 # treated as terminating errors, and will be caught by the catch block.
173 $args.ErrorAction = "Stop"
174
175 $retrycount = 0
176 $completed = $false
177
178 while (-not $completed) {
179 try {
180 & $command @args
181 Write-Verbose ("Command [{0}] succeeded." -f $command)
182 $completed = $true
183 } catch {
184 if ($retrycount -ge $retries) {
185 Write-Verbose ("Command [{0}] failed the maximum number of {1} times." -f $command, $retrycount)
186 throw
187 } else {
188 Write-Verbose ("Command [{0}] failed. Retrying in {1} seconds." -f $command, $secondsDelay)
189 Start-Sleep $secondsDelay
190 $retrycount++
191 }
192 }
193 }
194}
195
196
197Function Replace-DbQualifier ($stmt, $siteType, $dbConn) {
198 try {
199 if ($dbConn.GetType() -eq [System.Data.SqlClient.SqlConnection]) {
200 $stmt = $stmt.Replace("{$($siteType)Prefix}", "[$($dbConn.DataSource)].[$($dbConn.Database)].dbo.")
201 $stmt = $stmt.Replace("{$($siteType)Suffix}", "")
202 }
203 elseif ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
204 $schema = Get-ParameterValue $dbConn.ConnectionString "User ID=" ";"
205
206 $stmt = $stmt.Replace("{$($siteType)Prefix}", "$schema.")
207 $stmt = $stmt.Replace("{$($siteType)Suffix}", "@$($dbConn.DataSource)")
208 }
209 else {
210 throw "Unsupported database connection type: $($dbConn.GetType())"
211 }
212
213 return $stmt
214 }
215 catch {
216 throw ("Error in Replace-DbQualifier: " + $error[0])
217 }
218} # Replace-DbQualifier
219
220
221Function Merge-Value ($value1, $value2, $nullOption, $comparisonPreference) {
222 try {
223 if ($value1 -eq $value2) {
224 return $value1
225 }
226 elseif ($value1 -eq $null) {
227 if ($nullOption -eq "ReplaceNull") {return $value2}
228 else {throw "Unresolvable difference between null and $value2."}
229 }
230 elseif ($value2 -eq $null) {
231 if ($nullOption -eq "ReplaceNull") {return $value1}
232 else {throw "Unresolvable difference between $value1 and null."}
233 }
234 elseif ($comparisonPreference -eq "Lesser") {
235 return (@($value1,$value2) | Measure-Object -Minimum).Minimum
236 }
237 elseif ($comparisonPreference -eq "Greater") {
238 return (@($value1,$value2) | Measure-Object -Maximum).Maximum
239 }
240 elseif ($comparisonPreference -eq "Equal") {
241 throw "Unresolvable difference between $value1 and $value2."
242 }
243 else {
244 return $value1
245 }
246 }
247 catch {
248 throw ("Error in Merge-Value: " + $error[0])
249 }
250} # Merge-Value
251
252
253Function Select-Site ($siteName, $dbConn) {
254 try {
255 $cmd = New-Object System.Data.SqlClient.SqlCommand
256
257 $cmd.CommandText = "select siteid, sitename, siteuri from Site where sitename = @sitename"
258
259 $cmd.Parameters.Add("@sitename", [System.Data.SqlDbType]::VarChar) | Out-Null
260 $cmd.Parameters["@sitename"].Value = $siteName
261
262 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
263 $cmd = (ConvertTo-OracleCommand $cmd)
264 }
265
266 $cmd.Connection = $dbConn
267
268 $reader = $cmd.ExecuteReader()
269
270 if ($reader.Read()) {
271 $site = New-Object PSObject
272
273 $site | Add-Member NoteProperty SiteId (ConvertTo-PsType $reader[0])
274 $site | Add-Member NoteProperty SiteName (ConvertTo-PsType $reader[1])
275 $site | Add-Member NoteProperty SiteUri (ConvertTo-PsType $reader[2])
276 $site | Add-Member NoteProperty DbConn $dbConn
277 $site | Add-Member NoteProperty Devices $null
278 $site | Add-Member NoteProperty ActiveImagePath $null
279 $site | Add-Member NoteProperty IsMigrated $null
280 $site | Add-Member NoteProperty KnownIds $null
281
282 $siteArray += $site
283 }
284 else {
285 $site = $null
286 }
287
288 if ($reader.Read()) {throw "More than one site named $siteName."}
289
290 return $site
291 }
292 catch {
293 throw ("Error in Select-Site: " + $error[0])
294 }
295 finally {
296 if ($reader) {$reader.Close()}
297 }
298} # Select-Site
299
300
301Function Select-Devices ($dbConn) {
302 try {
303 $cmd = New-Object System.Data.SqlClient.SqlCommand
304
305 $cmd.CommandText = "
306 select deviceid, uncpath, devicetype, isdefault, filesperdirectory, cacheceiling,
307 cachefloor, disabled, deviceproperties
308 from Device
309 "
310
311 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
312 $cmd = (ConvertTo-OracleCommand $cmd)
313 }
314
315 $cmd.Connection = $dbConn
316
317 $reader = $cmd.ExecuteReader()
318
319 $deviceArray = @()
320
321 while ($reader.Read()) {
322 $device = New-Object PSObject
323
324 $device | Add-Member NoteProperty DeviceId (ConvertTo-PsType $reader[0])
325 $device | Add-Member NoteProperty UncPath (ConvertTo-PsType $reader[1])
326 $device | Add-Member NoteProperty DeviceType (ConvertTo-PsType $reader[2])
327 $device | Add-Member NoteProperty IsDefault (ConvertTo-PsType $reader[3])
328 $device | Add-Member NoteProperty FilesPerDirectory (ConvertTo-PsType $reader[4])
329 $device | Add-Member NoteProperty CacheCeiling (ConvertTo-PsType $reader[5])
330 $device | Add-Member NoteProperty CacheFloor (ConvertTo-PsType $reader[6])
331 $device | Add-Member NoteProperty Disabled (ConvertTo-PsType $reader[7])
332 $device | Add-Member NoteProperty DeviceProperties (ConvertTo-PsType $reader[8])
333
334 $deviceArray += $device
335 }
336
337 return ,$deviceArray # The comma ensures an array is returned even if there is only one element.
338 }
339 catch {
340 throw ("Error in Select-Devices: " + $error[0])
341 }
342 finally {
343 if ($reader) {$reader.Close()}
344 }
345} # Select-Devices
346
347
348Function Test-Ir3xLink ($dbConn) {
349 try {
350 $cmd = New-Object System.Data.SqlClient.SqlCommand
351
352 $cmd.CommandText = "select count(*) from Ir3xLink"
353
354 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
355 $cmd = (ConvertTo-OracleCommand $cmd)
356 }
357
358 $cmd.Connection = $dbConn
359
360 $deviceArray = @()
361
362 $cmd.ExecuteNonQuery() | Out-Null
363
364 return $true
365 }
366 catch {
367 return $false
368 }
369} # Test-Ir3xLink
370
371
372Function New-ActiveImagePath ($site) {
373 try {
374 $primaryDevice = ($site.Devices | Where-Object {$_.IsDefault -eq 1})
375
376 $activeImagePath = $site.ActiveImagePath
377
378 if ($activeImagePath -eq $null) {
379 $activeImagePath = New-Object PSObject
380 $activeImagePath | Add-Member NoteProperty PathDate ((Get-Date).Ticks -band 0x7FFFFFFF)
381 $activeImagePath | Add-Member NoteProperty DivisionNumber 0
382 $activeImagePath | Add-Member NoteProperty ImageCount 0
383 }
384 elseif ($activeImagePath.DivisionNumber -lt 1000) {
385 $activeImagePath.DivisionNumber++
386 $activeImagePath.ImageCount = 0
387 }
388 else {
389 $activeImagePath.PathDate = ((Get-Date).Ticks -band 0x7FFFFFFF)
390 $activeImagePath.DivisionNumber = 0
391 $activeImagePath.ImageCount = 0
392 }
393
394 $devicePath = $primaryDevice.UncPath
395 $pathDateHex = $activeImagePath.PathDate.ToString('X8')
396 $divisionNumberPad = $activeImagePath.DivisionNumber.ToString('D8')
397
398 $path = "$devicePath\$pathDateHex\$divisionNumberPad"
399
400 if (!(Test-Path $path)) {
401 New-Item "$devicePath\$pathDateHex\$divisionNumberPad" -ItemType Directory -ErrorAction Stop | Out-Null
402 }
403
404 return $activeImagePath
405 }
406 catch {
407 throw ("Error in New-ActiveImagePath: " + $error[0])
408 }
409} # New-ActiveImagePath
410
411
412# Create blank object once, so it can be copied to create new instances.
413# This results in huge performance gains.
414$global:blankProgress = New-Object PSObject
415$global:blankProgress | Add-Member NoteProperty SiteId $null
416$global:blankProgress | Add-Member NoteProperty ProgressType $null
417$global:blankProgress | Add-Member NoteProperty TotalCount 0
418$global:blankProgress | Add-Member NoteProperty CompleteCount 0
419$global:blankProgress | Add-Member NoteProperty ErrorCount 0
420
421Function Select-Progress ($siteId, $progressType, $dbConn, $dbTran) {
422 try {
423 $cmd = New-Object System.Data.SqlClient.SqlCommand
424
425 $cmd.CommandText = "
426 select totalcount, completecount, errorcount
427 from Progress (updlock)
428 where siteid = @siteid
429 and progresstype = @progresstype
430 "
431
432 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
433 $cmd.Parameters["@siteid"].Value = $siteId
434
435 $cmd.Parameters.Add("@progresstype", [System.Data.SqlDbType]::VarChar) | Out-Null
436 $cmd.Parameters["@progresstype"].Value = $progressType
437
438 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
439 $cmd = (ConvertTo-OracleCommand $cmd)
440 }
441
442 $cmd.Connection = $dbConn
443 $cmd.Transaction = $dbTran
444
445 $reader = $cmd.ExecuteReader()
446
447 $progress = $global:blankProgress.PSObject.Copy()
448 $progress.SiteId = $siteId
449 $progress.ProgressType = $progressType
450
451 if ($reader.Read()) {
452 $progress.TotalCount = ConvertTo-PsType $reader[0]
453 $progress.CompleteCount = ConvertTo-PsType $reader[1]
454 $progress.ErrorCount = ConvertTo-PsType $reader[2]
455 }
456
457 return $progress
458 }
459 catch {
460 throw ("Error in Select-Progress: " + $error[0])
461 }
462 finally {
463 if ($reader) {$reader.Close()}
464 }
465} # Select-Progress
466
467
468Function Update-Progress ($progress, $dbConn, $dbTran) {
469 try {
470 $cmd = New-Object System.Data.SqlClient.SqlCommand
471
472 $cmd.CommandText = "
473 update Progress
474 set totalcount = @totalcount, completecount = @completecount, errorcount = @errorcount
475 where siteid = @siteid
476 and progresstype = @progresstype
477 "
478
479 $cmd.Parameters.Add("@totalcount", [System.Data.SqlDbType]::Int) | Out-Null
480 $cmd.Parameters["@totalcount"].Value = ConvertTo-DbNull $progress.TotalCount
481
482 $cmd.Parameters.Add("@completecount", [System.Data.SqlDbType]::Int) | Out-Null
483 $cmd.Parameters["@completecount"].Value = ConvertTo-DbNull $progress.CompleteCount
484
485 $cmd.Parameters.Add("@errorcount", [System.Data.SqlDbType]::Int) | Out-Null
486 $cmd.Parameters["@errorcount"].Value = ConvertTo-DbNull $progress.ErrorCount
487
488 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
489 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $progress.SiteId
490
491 $cmd.Parameters.Add("@progresstype", [System.Data.SqlDbType]::VarChar) | Out-Null
492 $cmd.Parameters["@progresstype"].Value = ConvertTo-DbNull $progress.ProgressType
493
494 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
495 $cmd = (ConvertTo-OracleCommand $cmd)
496 }
497
498 $cmd.Connection = $dbConn
499 $cmd.Transaction = $dbTran
500
501 $rowsAffected = $cmd.ExecuteNonQuery()
502
503 return $rowsAffected
504 }
505 catch {
506 throw ("Error in Update-Progress: " + $error[0])
507 }
508} # Update-Progress
509
510
511Function Insert-Progress ($progress, $dbConn, $dbTran) {
512 try {
513 $cmd = New-Object System.Data.SqlClient.SqlCommand
514
515 $cmd.CommandText = "
516 insert into Progress (siteid, progresstype, totalcount, completecount, errorcount)
517 values (@siteid, @progresstype, @totalcount, @completecount, @errorcount)
518 "
519
520 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
521 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $progress.SiteId
522
523 $cmd.Parameters.Add("@progresstype", [System.Data.SqlDbType]::VarChar) | Out-Null
524 $cmd.Parameters["@progresstype"].Value = ConvertTo-DbNull $progress.ProgressType
525
526 $cmd.Parameters.Add("@totalcount", [System.Data.SqlDbType]::Int) | Out-Null
527 $cmd.Parameters["@totalcount"].Value = ConvertTo-DbNull $progress.TotalCount
528
529 $cmd.Parameters.Add("@completecount", [System.Data.SqlDbType]::Int) | Out-Null
530 $cmd.Parameters["@completecount"].Value = ConvertTo-DbNull $progress.CompleteCount
531
532 $cmd.Parameters.Add("@errorcount", [System.Data.SqlDbType]::Int) | Out-Null
533 $cmd.Parameters["@errorcount"].Value = ConvertTo-DbNull $progress.ErrorCount
534
535 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
536 $cmd = (ConvertTo-OracleCommand $cmd)
537 }
538
539 $cmd.Connection = $dbConn
540 $cmd.Transaction = $dbTran
541
542 $cmd.ExecuteNonQuery() | Out-Null
543
544 return $rowsAffected
545 }
546 catch {
547 throw ("Error in Insert-Progress: " + $error[0])
548 }
549} # Insert-Progress
550
551
552# Create blank object once, so it can be copied to create new instances.
553# This results in huge performance gains.
554$global:blankSyncIssue = New-Object PSObject
555$global:blankSyncIssue | Add-Member NoteProperty IssueId $null
556$global:blankSyncIssue | Add-Member NoteProperty SiteId $null
557$global:blankSyncIssue | Add-Member NoteProperty Type $null
558$global:blankSyncIssue | Add-Member NoteProperty ItemId $null
559$global:blankSyncIssue | Add-Member NoteProperty ItemId2 $null
560$global:blankSyncIssue | Add-Member NoteProperty Status $null
561$global:blankSyncIssue | Add-Member NoteProperty StatusTime $null
562
563Function Select-UnprocessedSyncIssue ($siteId, $type, $dbConn, $dbTran) {
564 try {
565 $cmd = New-Object System.Data.SqlClient.SqlCommand
566
567 $cmd.CommandText = "
568 select top 1 issueid, siteid, type, itemid, itemid2, status, statustime
569 from SyncIssue with (index = IX_SyncIssue_status_siteid)
570 where siteid = @siteid
571 and status = 'Unprocessed'
572 and type like @type
573 "
574
575 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
576 $cmd.Parameters["@siteid"].Value = $siteId
577
578 $cmd.Parameters.Add("@type", [System.Data.SqlDbType]::VarChar) | Out-Null
579 $cmd.Parameters["@type"].Value = $type
580
581 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
582 $cmd = (ConvertTo-OracleCommand $cmd)
583 }
584
585 $cmd.Connection = $dbConn
586 $cmd.Transaction = $dbTran
587
588 $reader = $cmd.ExecuteReader()
589
590 if ($reader.Read()) {
591 $syncIssue = $global:blankSyncIssue.PSObject.Copy()
592
593 $syncIssue.IssueId = ConvertTo-PsType $reader[0]
594 $syncIssue.SiteId = ConvertTo-PsType $reader[1]
595 $syncIssue.Type = ConvertTo-PsType $reader[2]
596 $syncIssue.ItemId = ConvertTo-PsType $reader[3]
597 $syncIssue.ItemId2 = ConvertTo-PsType $reader[4]
598 $syncIssue.Status = ConvertTo-PsType $reader[5]
599 $syncIssue.StatusTime = ConvertTo-PsType $reader[6]
600 }
601 else {
602 $syncIssue = $null
603 }
604
605 return $syncIssue
606 }
607 catch {
608 throw ("Error in Select-UnprocessedSyncIssue: " + $error[0])
609 }
610 finally {
611 if ($reader) {$reader.Close()}
612 }
613} # Select-UnprocessedSyncIssue
614
615
616Function Update-SyncIssue ($syncIssue, $dbConn, $dbTran) {
617 try {
618 $cmd = New-Object System.Data.SqlClient.SqlCommand
619
620 $cmd.CommandText = "
621 update SyncIssue
622 set status = @status, statustime = @statustime
623 where issueid = @issueid
624 "
625
626 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::VarChar) | Out-Null
627 $cmd.Parameters["@status"].Value = $syncIssue.Status
628
629 $cmd.Parameters.Add("@statustime", [System.Data.SqlDbType]::DateTime) | Out-Null
630 $cmd.Parameters["@statustime"].Value = (Get-Date)
631
632 $cmd.Parameters.Add("@issueid", [System.Data.SqlDbType]::Int) | Out-Null
633 $cmd.Parameters["@issueid"].Value = $syncIssue.IssueId
634
635 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
636 $cmd = (ConvertTo-OracleCommand $cmd)
637 }
638
639 $cmd.Connection = $dbConn
640 $cmd.Transaction = $dbTran
641
642 $rowsAffected = $cmd.ExecuteNonQuery()
643
644 return $rowsAffected
645 }
646 catch {
647 throw ("Error in Update-SyncIssue: " + $error[0])
648 }
649} # Update-SyncIssue
650
651
652Function Select-SyncIssueCount ($siteId, $dbConn, $dbTran) {
653 try {
654 $cmd = New-Object System.Data.SqlClient.SqlCommand
655
656 $cmd.CommandText = "
657 select count(*)
658 from SyncIssue
659 where siteid = @siteid
660 "
661
662 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
663 $cmd.Parameters["@siteid"].Value = $siteId
664
665 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
666 $cmd = (ConvertTo-OracleCommand $cmd)
667 }
668
669 $cmd.Connection = $dbConn
670 if ($dbTran) {$cmd.Transaction = $dbTran}
671
672 $count = ConvertTo-PsType $cmd.ExecuteScalar()
673
674 return $count
675 }
676 catch {
677 throw ("Error in Select-SyncIssueCount: " + $error[0])
678 }
679} # Select-SyncIssueCount
680
681
682Function Select-SyncIssueCountByStatus ($siteId, $status, $dbConn, $dbTran) {
683 try {
684 $cmd = New-Object System.Data.SqlClient.SqlCommand
685
686 $cmd.CommandText = "
687 select count(*)
688 from SyncIssue
689 where siteid = @siteid
690 and status = @status
691 "
692
693 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
694 $cmd.Parameters["@siteid"].Value = $siteId
695
696 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::VarChar) | Out-Null
697 $cmd.Parameters["@status"].Value = $status
698
699 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
700 $cmd = (ConvertTo-OracleCommand $cmd)
701 }
702
703 $cmd.Connection = $dbConn
704 if ($dbTran) {$cmd.Transaction = $dbTran}
705
706 $count = ConvertTo-PsType $cmd.ExecuteScalar()
707
708 return $count
709 }
710 catch {
711 throw ("Error in Select-SyncIssueCountByStatus: " + $error[0])
712 }
713} # Select-SyncIssueCountByStatus
714
715
716Function Reset-SyncIssueErrors ($siteId, $dbConn, $dbTran) {
717 try {
718 $cmd = New-Object System.Data.SqlClient.SqlCommand
719
720 $cmd.CommandText = "
721 update SyncIssue
722 set status = 'Unprocessed'
723 where siteid = @siteid
724 and status = 'Error'
725 "
726
727 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
728 $cmd.Parameters["@siteid"].Value = $siteId
729
730 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
731 $cmd = (ConvertTo-OracleCommand $cmd)
732 }
733
734 $cmd.Connection = $dbConn
735 $cmd.Transaction = $dbTran
736
737 $cmd.ExecuteNonQuery() | Out-Null
738 }
739 catch {
740 throw ("Error in Reset-SyncIssueErrors: " + $error[0])
741 }
742} # Reset-SyncIssueErrors
743
744
745Function Delete-SyncIssueBySite ($siteId, $dbConn) {
746 try {
747 $cmd = New-Object System.Data.SqlClient.SqlCommand
748
749 $cmd.CommandText = "delete from SyncIssue where siteid = @siteid"
750
751 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
752 $cmd.Parameters["@siteid"].Value = $siteId
753
754 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
755 $cmd = (ConvertTo-OracleCommand $cmd)
756 }
757
758 $cmd.Connection = $dbConn
759 $cmd.CommandTimeout = 0
760
761 $cmd.ExecuteNonQuery() | Out-Null
762 }
763 catch {
764 throw ("Error in Delete-SyncIssueBySite: " + $error[0])
765 }
766} # Delete-SyncIssueBySite
767
768
769Function Gather-SyncIssue ($type, $master, $satellite, $syncDb) {
770 try {
771 $cmd = New-Object System.Data.SqlClient.SqlCommand
772
773 $cmd.CommandText = $global:diffQueries[$type]
774
775 $cmd.Parameters.Add("@satelliteid", [System.Data.SqlDbType]::Int) | Out-Null
776 $cmd.Parameters["@satelliteid"].Value = $satellite.SiteId
777
778 $cmd.Parameters.Add("@statustime", [System.Data.SqlDbType]::DateTime) | Out-Null
779 $cmd.Parameters["@statustime"].Value = Get-Date
780
781 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Master" $master.DbConn
782 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Satellite" $satellite.DbConn
783
784 if ($syncDb.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
785 $cmd = (ConvertTo-OracleCommand $cmd)
786 }
787
788 $cmd.Connection = $syncDb
789 $cmd.CommandTimeout = 0
790
791 $cmd.ExecuteNonQuery() | Out-Null
792 }
793 catch {
794 throw ("Error in Gather-SyncIssue: $($type): " + $error[0])
795 }
796} # Gather-SyncIssue
797
798
799$global:diffQueries = @{}
800
801
802Function Get-MergedItem ($type, $id1, $id2, $sites) {
803 try {
804 $siteQueue = New-Object System.Collections.Queue
805 $item = $null
806 $relevantSiteIds = @(0)
807
808 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
809
810 while ($siteQueue.Count -gt 0 -and $item -eq $null) {
811 $site = $siteQueue.Dequeue()
812 $item = Get-IrItem $type $id1 $id2 $site
813 }
814
815 if ($item -eq $null) {
816 if ($id2 -eq $null) {throw "$type $id1 not found at any site."}
817 else {throw "$type ($id1, $id2) not found at any site."}
818 }
819
820 if ($site.SiteId -gt 0) {$relevantSiteIds += $site.SiteId}
821
822 while ($siteQueue.Count -gt 0) {
823 $site = $siteQueue.Dequeue()
824
825 $itemB = $null
826 $itemB = Get-IrItem $type $id1 $id2 $site
827
828 if ($itemB -ne $null) {
829 $relevantSiteIds += $site.SiteId
830
831 $item = & "Merge-Item" $item $itemB
832 }
833 }
834
835 if ($item.Owner -notin $relevantSiteIds -and $item.Owner -ne $null) {$relevantSiteIds += $item.Owner}
836 $item.RelevantSiteIds = $relevantSiteIds
837
838 return $item
839 }
840 catch {
841 throw ("Error in Get-MergedItem: " + $error[0])
842 }
843} # Get-MergedItem
844
845
846Function Get-IrItem ($type, $id1, $id2, $site) {
847 try {
848 if ($id2 -eq $null) {
849 $item = & "Select-$type" $id1 $site.DbConn
850 }
851 else {
852 $item = & "Select-$type" $id1 $id2 $site.DbConn
853 }
854
855 if ($item -ne $null) {$item.SiteId = $site.SiteId}
856
857 return $item
858 }
859 catch {
860 throw ("Error in Get-IrItem: " + $error[0])
861 }
862} # Get-IrItem
863
864
865Function Merge-Item ($item1, $item2) {
866 try {
867 if ($item1.ItemId -ne $item2.ItemId -or $item1.ItemId2 -ne $item2.ItemId2) {
868 throw "Cannot merge items with different ids."
869 }
870
871 $item = $null
872
873 if ($item1.Owner -eq $item1.SiteId -and $item2.Owner -ne $item2.SiteId) {
874 $item = & "Merge-$($item1.ItemType)" $item1 $item2
875 }
876 else {
877 $item = & "Merge-$($item1.ItemType)" $item2 $item1
878 }
879
880 return $item
881 }
882 catch {
883 throw ("Error in Merge-Item: " + $error[0])
884 }
885} # Merge-Item
886
887
888# Create blank object once, so it can be copied to create new instances.
889# This results in huge performance gains.
890$global:blankItem = New-Object PSObject
891$global:blankItem | Add-Member NoteProperty ItemId $null
892$global:blankItem | Add-Member NoteProperty ItemId2 $null
893$global:blankItem | Add-Member NoteProperty ItemType $null
894$global:blankItem | Add-Member NoteProperty Owner $null
895$global:blankItem | Add-Member NoteProperty SiteId $null
896$global:blankItem | Add-Member NoteProperty RelevantSiteIds @(0)
897
898Function Save-MergedItem ($item, $sites) {
899 try {
900 $siteQueue = New-Object System.Collections.Queue
901
902 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
903
904 while ($siteQueue.Count -gt 0) {
905 $site = $siteQueue.Dequeue()
906
907 Save-Item $item $site
908 }
909 }
910 catch {
911 throw ("Error in Save-MergedItem: " + $error[0])
912 }
913} # Save-MergedItem
914
915
916Function Save-Item ($item, $site) {
917 try {
918 if ($item.ItemType -eq "Task" -and ($item.SiteId -ne $item.Owner -or $site.SiteId -notin (0,$item.Owner))) {
919 Delete-TaskAttrBinaryByTaskId $item.ItemId $site.DbConn
920 Delete-TaskAttrCharByTaskId $item.ItemId $site.DbConn
921 Delete-TaskAttrDateByTaskId $item.ItemId $site.DbConn
922 Delete-TaskAttrFloatByTaskId $item.ItemId $site.DbConn
923 Delete-TaskAttrIntByTaskId $item.ItemId $site.DbConn
924 Delete-FlowStackByTaskId $item.ItemId $site.DbConn
925 Delete-SubTaskByTaskId $item.ItemId $site.DbConn
926 Delete-Task $item.ItemId $site.DbConn
927 }
928 elseif (($item.ItemType -like "TaskAttr*" -or $item.ItemType -in ("FlowStack","SubTask")) -and ($item.SiteId -ne $item.Owner)) {
929 & "Delete-$($item.ItemType)" $item $site.DbConn | Out-Null
930 }
931 else {
932 $localItem = $item.PSObject.Copy()
933
934 if ($site.SiteId -notin (0,$item.Owner)) {
935 $localItem.Owner = 0
936
937 if ($item.ItemType -eq "TaskMaster") {$localItem.ImageSetId = $null}
938 }
939
940 $recordsUpdated = & "Update-$($item.ItemType)" $localItem $site.DbConn
941 if ($recordsUpdated -eq 0) {& "Insert-$($item.ItemType)" $localItem $site.DbConn | Out-Null}
942 }
943 }
944 catch {
945 throw ("Error in Save-Item: " + $error[0])
946 }
947} # Save-Item
948
949
950$global:diffQueries["AttributeBinary_MasterNotAtSat"] = "
951 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
952 select @satelliteid, 'AttributeBinary', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
953 from {MasterPrefix}AttributeBinary{MasterSuffix} attr_mast
954 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
955 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
956 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
957 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid)
958 and not exists (
959 select 1
960 from {SatellitePrefix}AttributeBinary{SatelliteSuffix}
961 where objectid = attr_mast.objectid
962 and attributeid = attr_mast.attributeid
963 )
964"
965
966$global:diffQueries["AttributeBinary_SatNotAtMaster"] = "
967 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
968 select @satelliteid, 'AttributeBinary', attr_sat.objectid, attr_sat.attributeid, 'Unprocessed', @statustime
969 from {SatellitePrefix}AttributeBinary{SatelliteSuffix} attr_sat
970 where not exists (
971 select 1
972 from {MasterPrefix}AttributeBinary{MasterSuffix}
973 where objectid = attr_sat.objectid
974 and attributeid = attr_sat.attributeid
975 )
976"
977
978$global:diffQueries["AttributeBinary_MasterSatDiff"] = "
979 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
980 select @satelliteid, 'AttributeBinary', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
981 from {MasterPrefix}AttributeBinary{MasterSuffix} attr_mast
982 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
983 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
984 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
985 join {SatellitePrefix}AttributeBinary{SatelliteSuffix} attr_sat on attr_sat.objectid = attr_mast.objectid and attr_sat.attributeid = attr_mast.attributeid
986 left join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = attr_sat.objectid
987 left join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = attr_sat.objectid
988 left join {SatellitePrefix}Files{SatelliteSuffix} fdf_sat on fdf_sat.fileid = df_sat.fileid
989 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid or f_sat.owner = @satelliteid or fdf_sat.owner = @satelliteid)
990 and (
991 cast(attr_mast.binvalue as varbinary(max)) <> cast(attr_sat.binvalue as varbinary(max))
992 or attr_mast.binvalue is null and attr_sat.binvalue is not null
993 or attr_mast.binvalue is not null and attr_sat.binvalue is null
994 )
995"
996
997
998Function Merge-AttributeBinary ($attr1, $attr2) {
999 try {
1000 $attr1.Value = Merge-Value $attr1.Value $attr2.Value "ReplaceNull"
1001
1002 return $attr1
1003 }
1004 catch {
1005 throw ("Error in Merge-AttributeBinary: " + $error[0])
1006 }
1007} # Merge-AttributeBinary
1008
1009
1010# Create blank object once, so it can be copied to create new instances.
1011# This results in huge performance gains.
1012$global:blankAttributeBinary = $global:blankItem.PSObject.Copy()
1013$global:blankAttributeBinary.ItemType = "AttributeBinary"
1014$global:blankAttributeBinary | Add-Member NoteProperty Value $null
1015
1016Function Select-AttributeBinary ($objectId, $attributeId, $dbConn) {
1017 try {
1018 $cmd = New-Object System.Data.SqlClient.SqlCommand
1019
1020 $cmd.CommandText = "
1021 select case when f.owner is null then fdf.owner else f.owner end owner, a.binvalue
1022 from AttributeBinary a
1023 left join Files f on f.fileid = a.objectid
1024 left join DocFolder df on df.docfolderid = a.objectid
1025 left join Files fdf on fdf.fileid = df.fileid
1026 where a.objectid = @objectid
1027 and a.attributeid = @attributeid
1028 "
1029
1030 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1031 $cmd.Parameters["@objectid"].Value = $objectId
1032
1033 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1034 $cmd.Parameters["@attributeid"].Value = $attributeId
1035
1036 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1037 $cmd = (ConvertTo-OracleCommand $cmd)
1038 }
1039
1040 $cmd.Connection = $dbConn
1041
1042 $reader = $cmd.ExecuteReader()
1043
1044 if ($reader.Read()) {
1045 $attr = $global:blankAttributeBinary.PSObject.Copy()
1046
1047 $attr.ItemId = $objectId
1048 $attr.ItemId2 = $attributeId
1049 $attr.Owner = ConvertTo-PsType $reader[0]
1050 $attr.Value = ConvertTo-PsType $reader[1]
1051 }
1052 else {
1053 $attr = $null
1054 }
1055
1056 return $attr
1057 }
1058 catch {
1059 throw ("Error in Select-AttributeBinary: " + $error[0])
1060 }
1061 finally {
1062 if ($reader) {$reader.Close()}
1063 }
1064} # Select-AttributeBinary
1065
1066
1067Function Update-AttributeBinary ($attr, $dbConn) {
1068 try {
1069 $cmd = New-Object System.Data.SqlClient.SqlCommand
1070
1071 $cmd.CommandText = "
1072 update AttributeBinary
1073 set binvalue = @value
1074 where objectid = @objectid
1075 and attributeid = @attributeid
1076 "
1077
1078 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1079 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1080
1081 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1082 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1083
1084 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Image) | Out-Null
1085 if ($attr.Value -ne $null) {$cmd.Parameters["@value"].Value = [byte[]]$attr.Value}
1086 else {$cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)}
1087
1088 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1089 $cmd = (ConvertTo-OracleCommand $cmd)
1090 }
1091
1092 $cmd.Connection = $dbConn
1093
1094 $rowsAffected = $cmd.ExecuteNonQuery()
1095
1096 return $rowsAffected
1097 }
1098 catch {
1099 throw ("Error in Update-AttributeBinary: " + $error[0])
1100 }
1101} # Update-AttributeBinary
1102
1103
1104Function Insert-AttributeBinary ($attr, $dbConn) {
1105 try {
1106 $cmd = New-Object System.Data.SqlClient.SqlCommand
1107
1108 $cmd.CommandText = "
1109 insert into AttributeBinary (objectid, attributeid, binvalue)
1110 values (@objectid, @attributeid, @value)
1111 "
1112
1113 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1114 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1115
1116 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1117 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1118
1119 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Image) | Out-Null
1120 if ($attr.Value -ne $null) {$cmd.Parameters["@value"].Value = [byte[]]$attr.Value}
1121 else {$cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)}
1122
1123 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1124 $cmd = (ConvertTo-OracleCommand $cmd)
1125 }
1126
1127 $cmd.Connection = $dbConn
1128
1129 $rowsAffected = $cmd.ExecuteNonQuery()
1130
1131 return $rowsAffected
1132 }
1133 catch {
1134 throw ("Error in Insert-AttributeBinary: " + $error[0])
1135 }
1136} # Insert-AttributeBinary
1137
1138
1139$global:diffQueries["AttributeChar_MasterNotAtSat"] = "
1140 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1141 select @satelliteid, 'AttributeChar', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
1142 from {MasterPrefix}AttributeChar{MasterSuffix} attr_mast
1143 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
1144 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
1145 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
1146 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid)
1147 and not exists (
1148 select 1
1149 from {SatellitePrefix}AttributeChar{SatelliteSuffix}
1150 where objectid = attr_mast.objectid
1151 and attributeid = attr_mast.attributeid
1152 )
1153"
1154
1155$global:diffQueries["AttributeChar_SatNotAtMaster"] = "
1156 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1157 select @satelliteid, 'AttributeChar', attr_sat.objectid, attr_sat.attributeid, 'Unprocessed', @statustime
1158 from {SatellitePrefix}AttributeChar{SatelliteSuffix} attr_sat
1159 where not exists (
1160 select 1
1161 from {MasterPrefix}AttributeChar{MasterSuffix}
1162 where objectid = attr_sat.objectid
1163 and attributeid = attr_sat.attributeid
1164 )
1165"
1166
1167$global:diffQueries["AttributeChar_MasterSatDiff"] = "
1168 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1169 select @satelliteid, 'AttributeChar', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
1170 from {MasterPrefix}AttributeChar{MasterSuffix} attr_mast
1171 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
1172 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
1173 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
1174 join {SatellitePrefix}AttributeChar{SatelliteSuffix} attr_sat on attr_sat.objectid = attr_mast.objectid and attr_sat.attributeid = attr_mast.attributeid
1175 left join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = attr_sat.objectid
1176 left join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = attr_sat.objectid
1177 left join {SatellitePrefix}Files{SatelliteSuffix} fdf_sat on fdf_sat.fileid = df_sat.fileid
1178 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid or f_sat.owner = @satelliteid or fdf_sat.owner = @satelliteid)
1179 and (
1180 attr_mast.charvalue <> attr_sat.charvalue
1181 or attr_mast.charvalue is null and attr_sat.charvalue is not null
1182 or attr_mast.charvalue is not null and attr_sat.charvalue is null
1183 )
1184"
1185
1186
1187Function Merge-AttributeChar ($attr1, $attr2) {
1188 try {
1189 $attr1.Value = Merge-Value $attr1.Value $attr2.Value "ReplaceNull"
1190
1191 return $attr1
1192 }
1193 catch {
1194 throw ("Error in Merge-AttributeChar: " + $error[0])
1195 }
1196} # Merge-AttributeChar
1197
1198
1199# Create blank object once, so it can be copied to create new instances.
1200# This results in huge performance gains.
1201$global:blankAttributeChar = $global:blankItem.PSObject.Copy()
1202$global:blankAttributeChar.ItemType = "AttributeChar"
1203$global:blankAttributeChar | Add-Member NoteProperty Value $null
1204
1205Function Select-AttributeChar ($objectId, $attributeId, $dbConn) {
1206 try {
1207 $cmd = New-Object System.Data.SqlClient.SqlCommand
1208
1209 $cmd.CommandText = "
1210 select case when f.owner is null then fdf.owner else f.owner end owner, a.charvalue
1211 from AttributeChar a
1212 left join Files f on f.fileid = a.objectid
1213 left join DocFolder df on df.docfolderid = a.objectid
1214 left join Files fdf on fdf.fileid = df.fileid
1215 where a.objectid = @objectid
1216 and a.attributeid = @attributeid
1217 "
1218
1219 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1220 $cmd.Parameters["@objectid"].Value = $objectId
1221
1222 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1223 $cmd.Parameters["@attributeid"].Value = $attributeId
1224
1225 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1226 $cmd = (ConvertTo-OracleCommand $cmd)
1227 }
1228
1229 $cmd.Connection = $dbConn
1230
1231 $reader = $cmd.ExecuteReader()
1232
1233 if ($reader.Read()) {
1234 $attr = $global:blankAttributeChar.PSObject.Copy()
1235
1236 $attr.ItemId = $objectId
1237 $attr.ItemId2 = $attributeId
1238 $attr.Owner = ConvertTo-PsType $reader[0]
1239 $attr.Value = ConvertTo-PsType $reader[1]
1240 }
1241 else {
1242 $attr = $null
1243 }
1244
1245 return $attr
1246 }
1247 catch {
1248 throw ("Error in Select-AttributeChar: " + $error[0])
1249 }
1250 finally {
1251 if ($reader) {$reader.Close()}
1252 }
1253} # Select-AttributeChar
1254
1255
1256Function Update-AttributeChar ($attr, $dbConn) {
1257 try {
1258 $cmd = New-Object System.Data.SqlClient.SqlCommand
1259
1260 $cmd.CommandText = "
1261 update AttributeChar
1262 set charvalue = @value
1263 where objectid = @objectid
1264 and attributeid = @attributeid
1265 "
1266
1267 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1268 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1269
1270 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1271 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1272
1273 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::VarChar) | Out-Null
1274 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
1275
1276 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1277 $cmd = (ConvertTo-OracleCommand $cmd)
1278 }
1279
1280 $cmd.Connection = $dbConn
1281
1282 $rowsAffected = $cmd.ExecuteNonQuery()
1283
1284 return $rowsAffected
1285 }
1286 catch {
1287 throw ("Error in Update-AttributeChar: " + $error[0])
1288 }
1289} # Update-AttributeChar
1290
1291
1292Function Insert-AttributeChar ($attr, $dbConn) {
1293 try {
1294 $cmd = New-Object System.Data.SqlClient.SqlCommand
1295
1296 $cmd.CommandText = "
1297 insert into AttributeChar (objectid, attributeid, charvalue)
1298 values (@objectid, @attributeid, @value)
1299 "
1300
1301 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1302 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1303
1304 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1305 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1306
1307 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::VarChar) | Out-Null
1308 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
1309
1310 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1311 $cmd = (ConvertTo-OracleCommand $cmd)
1312 }
1313
1314 $cmd.Connection = $dbConn
1315
1316 $rowsAffected = $cmd.ExecuteNonQuery()
1317
1318 return $rowsAffected
1319 }
1320 catch {
1321 throw ("Error in Insert-AttributeChar: " + $error[0])
1322 }
1323} # Insert-AttributeChar
1324
1325
1326$global:diffQueries["AttributeDate_MasterNotAtSat"] = "
1327 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1328 select @satelliteid, 'AttributeDate', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
1329 from {MasterPrefix}AttributeDate{MasterSuffix} attr_mast
1330 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
1331 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
1332 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
1333 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid)
1334 and not exists (
1335 select 1
1336 from {SatellitePrefix}AttributeDate{SatelliteSuffix}
1337 where objectid = attr_mast.objectid
1338 and attributeid = attr_mast.attributeid
1339 )
1340"
1341
1342$global:diffQueries["AttributeDate_SatNotAtMaster"] = "
1343 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1344 select @satelliteid, 'AttributeDate', attr_sat.objectid, attr_sat.attributeid, 'Unprocessed', @statustime
1345 from {SatellitePrefix}AttributeDate{SatelliteSuffix} attr_sat
1346 where not exists (
1347 select 1
1348 from {MasterPrefix}AttributeDate{MasterSuffix}
1349 where objectid = attr_sat.objectid
1350 and attributeid = attr_sat.attributeid
1351 )
1352"
1353
1354$global:diffQueries["AttributeDate_MasterSatDiff"] = "
1355 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1356 select @satelliteid, 'AttributeDate', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
1357 from {MasterPrefix}AttributeDate{MasterSuffix} attr_mast
1358 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
1359 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
1360 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
1361 join {SatellitePrefix}AttributeDate{SatelliteSuffix} attr_sat on attr_sat.objectid = attr_mast.objectid and attr_sat.attributeid = attr_mast.attributeid
1362 left join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = attr_sat.objectid
1363 left join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = attr_sat.objectid
1364 left join {SatellitePrefix}Files{SatelliteSuffix} fdf_sat on fdf_sat.fileid = df_sat.fileid
1365 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid or f_sat.owner = @satelliteid or fdf_sat.owner = @satelliteid)
1366 and (
1367 attr_mast.datevalue <> attr_sat.datevalue
1368 or attr_mast.datevalue is null and attr_sat.datevalue is not null
1369 or attr_mast.datevalue is not null and attr_sat.datevalue is null
1370 )
1371"
1372
1373
1374Function Merge-AttributeDate ($attr1, $attr2) {
1375 try {
1376 $attr1.Value = Merge-Value $attr1.Value $attr2.Value "ReplaceNull"
1377
1378 return $attr1
1379 }
1380 catch {
1381 throw ("Error in Merge-AttributeDate: " + $error[0])
1382 }
1383} # Merge-AttributeDate
1384
1385
1386# Create blank object once, so it can be copied to create new instances.
1387# This results in huge performance gains.
1388$global:blankAttributeDate = $global:blankItem.PSObject.Copy()
1389$global:blankAttributeDate.ItemType = "AttributeDate"
1390$global:blankAttributeDate | Add-Member NoteProperty Value $null
1391
1392Function Select-AttributeDate ($objectId, $attributeId, $dbConn) {
1393 try {
1394 $cmd = New-Object System.Data.SqlClient.SqlCommand
1395
1396 $cmd.CommandText = "
1397 select case when f.owner is null then fdf.owner else f.owner end owner, a.datevalue
1398 from AttributeDate a
1399 left join Files f on f.fileid = a.objectid
1400 left join DocFolder df on df.docfolderid = a.objectid
1401 left join Files fdf on fdf.fileid = df.fileid
1402 where a.objectid = @objectid
1403 and a.attributeid = @attributeid
1404 "
1405
1406 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1407 $cmd.Parameters["@objectid"].Value = $objectId
1408
1409 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1410 $cmd.Parameters["@attributeid"].Value = $attributeId
1411
1412 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1413 $cmd = (ConvertTo-OracleCommand $cmd)
1414 }
1415
1416 $cmd.Connection = $dbConn
1417
1418 $reader = $cmd.ExecuteReader()
1419
1420 if ($reader.Read()) {
1421 $attr = $global:blankAttributeDate.PSObject.Copy()
1422
1423 $attr.ItemId = $objectId
1424 $attr.ItemId2 = $attributeId
1425 $attr.Owner = ConvertTo-PsType $reader[0]
1426 $attr.Value = ConvertTo-PsType $reader[1]
1427 }
1428 else {
1429 $attr = $null
1430 }
1431
1432 return $attr
1433 }
1434 catch {
1435 throw ("Error in Select-AttributeDate: " + $error[0])
1436 }
1437 finally {
1438 if ($reader) {$reader.Close()}
1439 }
1440} # Select-AttributeDate
1441
1442
1443Function Update-AttributeDate ($attr, $dbConn) {
1444 try {
1445 $cmd = New-Object System.Data.SqlClient.SqlCommand
1446
1447 $cmd.CommandText = "
1448 update AttributeDate
1449 set datevalue = @value
1450 where objectid = @objectid
1451 and attributeid = @attributeid
1452 "
1453
1454 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1455 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1456
1457 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1458 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1459
1460 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::DateTime) | Out-Null
1461 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
1462
1463 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1464 $cmd = (ConvertTo-OracleCommand $cmd)
1465 }
1466
1467 $cmd.Connection = $dbConn
1468
1469 $rowsAffected = $cmd.ExecuteNonQuery()
1470
1471 return $rowsAffected
1472 }
1473 catch {
1474 throw ("Error in Update-AttributeDate: " + $error[0])
1475 }
1476} # Update-AttributeDate
1477
1478
1479Function Insert-AttributeDate ($attr, $dbConn) {
1480 try {
1481 $cmd = New-Object System.Data.SqlClient.SqlCommand
1482
1483 $cmd.CommandText = "
1484 insert into AttributeDate (objectid, attributeid, datevalue)
1485 values (@objectid, @attributeid, @value)
1486 "
1487
1488 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1489 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1490
1491 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1492 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1493
1494 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::DateTime) | Out-Null
1495 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
1496
1497 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1498 $cmd = (ConvertTo-OracleCommand $cmd)
1499 }
1500
1501 $cmd.Connection = $dbConn
1502
1503 $rowsAffected = $cmd.ExecuteNonQuery()
1504
1505 return $rowsAffected
1506 }
1507 catch {
1508 throw ("Error in Insert-AttributeDate: " + $error[0])
1509 }
1510} # Insert-AttributeDate
1511
1512
1513$global:diffQueries["AttributeFloat_MasterNotAtSat"] = "
1514 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1515 select @satelliteid, 'AttributeFloat', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
1516 from {MasterPrefix}AttributeFloat{MasterSuffix} attr_mast
1517 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
1518 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
1519 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
1520 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid)
1521 and not exists (
1522 select 1
1523 from {SatellitePrefix}AttributeFloat{SatelliteSuffix}
1524 where objectid = attr_mast.objectid
1525 and attributeid = attr_mast.attributeid
1526 )
1527"
1528
1529$global:diffQueries["AttributeFloat_SatNotAtMaster"] = "
1530 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1531 select @satelliteid, 'AttributeFloat', attr_sat.objectid, attr_sat.attributeid, 'Unprocessed', @statustime
1532 from {SatellitePrefix}AttributeFloat{SatelliteSuffix} attr_sat
1533 where not exists (
1534 select 1
1535 from {MasterPrefix}AttributeFloat{MasterSuffix}
1536 where objectid = attr_sat.objectid
1537 and attributeid = attr_sat.attributeid
1538 )
1539"
1540
1541$global:diffQueries["AttributeFloat_MasterSatDiff"] = "
1542 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1543 select @satelliteid, 'AttributeFloat', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
1544 from {MasterPrefix}AttributeFloat{MasterSuffix} attr_mast
1545 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
1546 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
1547 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
1548 join {SatellitePrefix}AttributeFloat{SatelliteSuffix} attr_sat on attr_sat.objectid = attr_mast.objectid and attr_sat.attributeid = attr_mast.attributeid
1549 left join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = attr_sat.objectid
1550 left join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = attr_sat.objectid
1551 left join {SatellitePrefix}Files{SatelliteSuffix} fdf_sat on fdf_sat.fileid = df_sat.fileid
1552 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid or f_sat.owner = @satelliteid or fdf_sat.owner = @satelliteid)
1553 and (
1554 attr_mast.floatvalue <> attr_sat.floatvalue
1555 or attr_mast.floatvalue is null and attr_sat.floatvalue is not null
1556 or attr_mast.floatvalue is not null and attr_sat.floatvalue is null
1557 )
1558"
1559
1560
1561Function Merge-AttributeFloat ($attr1, $attr2) {
1562 try {
1563 $attr1.Value = Merge-Value $attr1.Value $attr2.Value "ReplaceNull"
1564
1565 return $attr1
1566 }
1567 catch {
1568 throw ("Error in Merge-AttributeFloat: " + $error[0])
1569 }
1570} # Merge-AttributeFloat
1571
1572
1573# Create blank object once, so it can be copied to create new instances.
1574# This results in huge performance gains.
1575$global:blankAttributeFloat = $global:blankItem.PSObject.Copy()
1576$global:blankAttributeFloat.ItemType = "AttributeFloat"
1577$global:blankAttributeFloat | Add-Member NoteProperty Value $null
1578
1579Function Select-AttributeFloat ($objectId, $attributeId, $dbConn) {
1580 try {
1581 $cmd = New-Object System.Data.SqlClient.SqlCommand
1582
1583 $cmd.CommandText = "
1584 select case when f.owner is null then fdf.owner else f.owner end owner, a.floatvalue
1585 from AttributeFloat a
1586 left join Files f on f.fileid = a.objectid
1587 left join DocFolder df on df.docfolderid = a.objectid
1588 left join Files fdf on fdf.fileid = df.fileid
1589 where a.objectid = @objectid
1590 and a.attributeid = @attributeid
1591 "
1592
1593 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1594 $cmd.Parameters["@objectid"].Value = $objectId
1595
1596 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1597 $cmd.Parameters["@attributeid"].Value = $attributeId
1598
1599 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1600 $cmd = (ConvertTo-OracleCommand $cmd)
1601 }
1602
1603 $cmd.Connection = $dbConn
1604
1605 $reader = $cmd.ExecuteReader()
1606
1607 if ($reader.Read()) {
1608 $attr = $global:blankAttributeFloat.PSObject.Copy()
1609
1610 $attr.ItemId = $objectId
1611 $attr.ItemId2 = $attributeId
1612 $attr.Owner = ConvertTo-PsType $reader[0]
1613 $attr.Value = ConvertTo-PsType $reader[1]
1614 }
1615 else {
1616 $attr = $null
1617 }
1618
1619 return $attr
1620 }
1621 catch {
1622 throw ("Error in Select-AttributeFloat: " + $error[0])
1623 }
1624 finally {
1625 if ($reader) {$reader.Close()}
1626 }
1627} # Select-AttributeFloat
1628
1629
1630Function Update-AttributeFloat ($attr, $dbConn) {
1631 try {
1632 $cmd = New-Object System.Data.SqlClient.SqlCommand
1633
1634 $cmd.CommandText = "
1635 update AttributeFloat
1636 set floatvalue = @value
1637 where objectid = @objectid
1638 and attributeid = @attributeid
1639 "
1640
1641 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1642 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1643
1644 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1645 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1646
1647 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Float) | Out-Null
1648 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
1649
1650 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1651 $cmd = (ConvertTo-OracleCommand $cmd)
1652 }
1653
1654 $cmd.Connection = $dbConn
1655
1656 $rowsAffected = $cmd.ExecuteNonQuery()
1657
1658 return $rowsAffected
1659 }
1660 catch {
1661 throw ("Error in Update-AttributeFloat: " + $error[0])
1662 }
1663} # Update-AttributeFloat
1664
1665
1666Function Insert-AttributeFloat ($attr, $dbConn) {
1667 try {
1668 $cmd = New-Object System.Data.SqlClient.SqlCommand
1669
1670 $cmd.CommandText = "
1671 insert into AttributeFloat (objectid, attributeid, floatvalue)
1672 values (@objectid, @attributeid, @value)
1673 "
1674
1675 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1676 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1677
1678 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1679 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1680
1681 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Float) | Out-Null
1682 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
1683
1684 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1685 $cmd = (ConvertTo-OracleCommand $cmd)
1686 }
1687
1688 $cmd.Connection = $dbConn
1689
1690 $rowsAffected = $cmd.ExecuteNonQuery()
1691
1692 return $rowsAffected
1693 }
1694 catch {
1695 throw ("Error in Insert-AttributeFloat: " + $error[0])
1696 }
1697} # Insert-AttributeFloat
1698
1699
1700$global:diffQueries["AttributeInt_MasterNotAtSat"] = "
1701 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1702 select @satelliteid, 'AttributeInt', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
1703 from {MasterPrefix}AttributeInt{MasterSuffix} attr_mast
1704 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
1705 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
1706 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
1707 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid)
1708 and not exists (
1709 select 1
1710 from {SatellitePrefix}AttributeInt{SatelliteSuffix}
1711 where objectid = attr_mast.objectid
1712 and attributeid = attr_mast.attributeid
1713 )
1714"
1715
1716$global:diffQueries["AttributeInt_SatNotAtMaster"] = "
1717 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1718 select @satelliteid, 'AttributeInt', attr_sat.objectid, attr_sat.attributeid, 'Unprocessed', @statustime
1719 from {SatellitePrefix}AttributeInt{SatelliteSuffix} attr_sat
1720 where not exists (
1721 select 1
1722 from {MasterPrefix}AttributeInt{MasterSuffix}
1723 where objectid = attr_sat.objectid
1724 and attributeid = attr_sat.attributeid
1725 )
1726"
1727
1728$global:diffQueries["AttributeInt_MasterSatDiff"] = "
1729 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1730 select @satelliteid, 'AttributeInt', attr_mast.objectid, attr_mast.attributeid, 'Unprocessed', @statustime
1731 from {MasterPrefix}AttributeInt{MasterSuffix} attr_mast
1732 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = attr_mast.objectid
1733 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = attr_mast.objectid
1734 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
1735 join {SatellitePrefix}AttributeInt{SatelliteSuffix} attr_sat on attr_sat.objectid = attr_mast.objectid and attr_sat.attributeid = attr_mast.attributeid
1736 left join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = attr_sat.objectid
1737 left join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = attr_sat.objectid
1738 left join {SatellitePrefix}Files{SatelliteSuffix} fdf_sat on fdf_sat.fileid = df_sat.fileid
1739 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid or f_sat.owner = @satelliteid or fdf_sat.owner = @satelliteid)
1740 and (
1741 attr_mast.intvalue <> attr_sat.intvalue
1742 or attr_mast.intvalue is null and attr_sat.intvalue is not null
1743 or attr_mast.intvalue is not null and attr_sat.intvalue is null
1744 )
1745"
1746
1747
1748Function Merge-AttributeInt ($attr1, $attr2) {
1749 try {
1750 $attr1.Value = Merge-Value $attr1.Value $attr2.Value "ReplaceNull"
1751
1752 return $attr1
1753 }
1754 catch {
1755 throw ("Error in Merge-AttributeInt: " + $error[0])
1756 }
1757} # Merge-AttributeInt
1758
1759
1760# Create blank object once, so it can be copied to create new instances.
1761# This results in huge performance gains.
1762$global:blankAttributeInt = $global:blankItem.PSObject.Copy()
1763$global:blankAttributeInt.ItemType = "AttributeInt"
1764$global:blankAttributeInt | Add-Member NoteProperty Value $null
1765
1766Function Select-AttributeInt ($objectId, $attributeId, $dbConn) {
1767 try {
1768 $cmd = New-Object System.Data.SqlClient.SqlCommand
1769
1770 $cmd.CommandText = "
1771 select case when f.owner is null then fdf.owner else f.owner end owner, a.intvalue
1772 from AttributeInt a
1773 left join Files f on f.fileid = a.objectid
1774 left join DocFolder df on df.docfolderid = a.objectid
1775 left join Files fdf on fdf.fileid = df.fileid
1776 where a.objectid = @objectid
1777 and a.attributeid = @attributeid
1778 "
1779
1780 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1781 $cmd.Parameters["@objectid"].Value = $objectId
1782
1783 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1784 $cmd.Parameters["@attributeid"].Value = $attributeId
1785
1786 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1787 $cmd = (ConvertTo-OracleCommand $cmd)
1788 }
1789
1790 $cmd.Connection = $dbConn
1791
1792 $reader = $cmd.ExecuteReader()
1793
1794 if ($reader.Read()) {
1795 $attr = $global:blankAttributeInt.PSObject.Copy()
1796
1797 $attr.ItemId = $objectId
1798 $attr.ItemId2 = $attributeId
1799 $attr.Owner = ConvertTo-PsType $reader[0]
1800 $attr.Value = ConvertTo-PsType $reader[1]
1801 }
1802 else {
1803 $attr = $null
1804 }
1805
1806 return $attr
1807 }
1808 catch {
1809 throw ("Error in Select-AttributeInt: " + $error[0])
1810 }
1811 finally {
1812 if ($reader) {$reader.Close()}
1813 }
1814} # Select-AttributeInt
1815
1816
1817Function Update-AttributeInt ($attr, $dbConn) {
1818 try {
1819 $cmd = New-Object System.Data.SqlClient.SqlCommand
1820
1821 $cmd.CommandText = "
1822 update AttributeInt
1823 set intvalue = @value
1824 where objectid = @objectid
1825 and attributeid = @attributeid
1826 "
1827
1828 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1829 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1830
1831 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1832 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1833
1834 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Int) | Out-Null
1835 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
1836
1837 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1838 $cmd = (ConvertTo-OracleCommand $cmd)
1839 }
1840
1841 $cmd.Connection = $dbConn
1842
1843 $rowsAffected = $cmd.ExecuteNonQuery()
1844
1845 return $rowsAffected
1846 }
1847 catch {
1848 throw ("Error in Update-AttributeInt: " + $error[0])
1849 }
1850} # Update-AttributeInt
1851
1852
1853Function Insert-AttributeInt ($attr, $dbConn) {
1854 try {
1855 $cmd = New-Object System.Data.SqlClient.SqlCommand
1856
1857 $cmd.CommandText = "
1858 insert into AttributeInt (objectid, attributeid, intvalue)
1859 values (@objectid, @attributeid, @value)
1860 "
1861
1862 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
1863 $cmd.Parameters["@objectid"].Value = $attr.ItemId
1864
1865 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
1866 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
1867
1868 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Int) | Out-Null
1869 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
1870
1871 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1872 $cmd = (ConvertTo-OracleCommand $cmd)
1873 }
1874
1875 $cmd.Connection = $dbConn
1876
1877 $rowsAffected = $cmd.ExecuteNonQuery()
1878
1879 return $rowsAffected
1880 }
1881 catch {
1882 throw ("Error in Insert-AttributeInt: " + $error[0])
1883 }
1884} # Insert-AttributeInt
1885
1886
1887$global:diffQueries["Batch_MasterNotAtSat"] = "
1888 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1889 select @satelliteid, 'Batch', b_mast.batchid, null, 'Unprocessed', @statustime
1890 from {MasterPrefix}Batches{MasterSuffix} b_mast
1891 where b_mast.owner = @satelliteid
1892 and not exists (
1893 select 1
1894 from {SatellitePrefix}Batches{SatelliteSuffix}
1895 where batchid = b_mast.batchid
1896 )
1897"
1898
1899$global:diffQueries["Batch_SatNotAtMaster"] = "
1900 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1901 select @satelliteid, 'Batch', b_sat.batchid, null, 'Unprocessed', @statustime
1902 from {SatellitePrefix}Batches{SatelliteSuffix} b_sat
1903 where not exists (
1904 select 1
1905 from {MasterPrefix}Batches{MasterSuffix}
1906 where batchid = b_sat.batchid
1907 )
1908"
1909
1910$global:diffQueries["Batch_MasterSatDiff"] = "
1911 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
1912 select @satelliteid, 'Batch', b_mast.batchid, null, 'Unprocessed', @statustime
1913 from {MasterPrefix}Batches{MasterSuffix} b_mast
1914 join {SatellitePrefix}Batches{SatelliteSuffix} b_sat on b_sat.batchid = b_mast.batchid
1915 where b_mast.datecaptured <> b_sat.datecaptured
1916 or b_mast.datecreated <> b_sat.datecreated
1917 or b_mast.datecreated is null and b_sat.datecreated is not null
1918 or b_mast.datecreated is not null and b_sat.datecreated is null
1919 or b_mast.numberdocs <> b_sat.numberdocs
1920 or b_mast.numberdocs is null and b_sat.numberdocs is not null
1921 or b_mast.numberdocs is not null and b_sat.numberdocs is null
1922 or b_mast.numberpages <> b_sat.numberpages
1923 or b_mast.numberpages is null and b_sat.numberpages is not null
1924 or b_mast.numberpages is not null and b_sat.numberpages is null
1925 or b_mast.programid <> b_sat.programid
1926 or b_mast.accountid <> b_sat.accountid
1927 or b_mast.boxid <> b_sat.boxid
1928 or b_mast.boxid is null and b_sat.boxid is not null
1929 or b_mast.boxid is not null and b_sat.boxid is null
1930 or b_mast.owner <> b_sat.owner and b_mast.owner in (0,@satelliteid) and b_sat.owner in (0,@satelliteid)
1931 or b_mast.owner is null and b_sat.owner is not null
1932 or b_mast.owner is not null and b_sat.owner is null
1933"
1934
1935
1936Function Merge-Batch ($batch1, $batch2) {
1937 try {
1938 $batch1.DateCaptured = Merge-Value $batch1.DateCaptured $batch2.DateCaptured "ReplaceNull" "Lesser"
1939 $batch1.DateCreated = Merge-Value $batch1.DateCreated $batch2.DateCreated "ReplaceNull" "Lesser"
1940 $batch1.NumberDocs = Merge-Value $batch1.NumberDocs $batch2.NumberDocs "ReplaceNull"
1941 $batch1.NumberPages = Merge-Value $batch1.NumberPages $batch2.NumberPages "ReplaceNull"
1942 $batch1.BoxId = Merge-Value $batch1.BoxId $batch2.BoxId "ReplaceNull"
1943 $batch1.Owner = Merge-Value $batch1.Owner $batch2.Owner "ReplaceNull"
1944
1945 return $batch1
1946 }
1947 catch {
1948 throw ("Error in Merge-Batch: " + $error[0])
1949 }
1950} # Merge-Batch
1951
1952
1953# Create blank object once, so it can be copied to create new instances.
1954# This results in huge performance gains.
1955$global:blankBatch = $global:blankItem.PSObject.Copy()
1956$global:blankBatch.ItemType = "Batch"
1957$global:blankBatch | Add-Member NoteProperty DateCaptured $null
1958$global:blankBatch | Add-Member NoteProperty DateCreated $null
1959$global:blankBatch | Add-Member NoteProperty NumberDocs $null
1960$global:blankBatch | Add-Member NoteProperty NumberPages $null
1961$global:blankBatch | Add-Member NoteProperty ProgramId $nulll
1962$global:blankBatch | Add-Member NoteProperty AccountId $null
1963$global:blankBatch | Add-Member NoteProperty BoxId $null
1964
1965Function Select-Batch ($batchId, $dbConn) {
1966 try {
1967 $cmd = New-Object System.Data.SqlClient.SqlCommand
1968
1969 $cmd.CommandText = "
1970 select owner, datecaptured, datecreated, numberdocs, numberpages, programid, accountid, boxid
1971 from Batches
1972 where batchid = @batchid
1973 "
1974
1975 $cmd.Parameters.Add("@batchid", [System.Data.SqlDbType]::Int) | Out-Null
1976 $cmd.Parameters["@batchid"].Value = $batchId
1977
1978 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
1979 $cmd = (ConvertTo-OracleCommand $cmd)
1980 }
1981
1982 $cmd.Connection = $dbConn
1983
1984 $reader = $cmd.ExecuteReader()
1985
1986 if ($reader.Read()) {
1987 $batch = $global:blankBatch.PSObject.Copy()
1988
1989 $batch.ItemId = $batchId
1990 $batch.ItemId2 = $null
1991 $batch.Owner = ConvertTo-PsType $reader[0]
1992 $batch.DateCaptured = ConvertTo-PsType $reader[1]
1993 $batch.DateCreated = ConvertTo-PsType $reader[2]
1994 $batch.NumberDocs = ConvertTo-PsType $reader[3]
1995 $batch.NumberPages = ConvertTo-PsType $reader[4]
1996 $batch.ProgramId = ConvertTo-PsType $reader[5]
1997 $batch.AccountId = ConvertTo-PsType $reader[6]
1998 $batch.BoxId = ConvertTo-PsType $reader[7]
1999 }
2000 else {
2001 $batch = $null
2002 }
2003
2004 return $batch
2005 }
2006 catch {
2007 throw ("Error in Select-Batch: " + $error[0])
2008 }
2009 finally {
2010 if ($reader) {$reader.Close()}
2011 }
2012} # Select-Batch
2013
2014
2015Function Update-Batch ($batch, $dbConn) {
2016 try {
2017 $cmd = New-Object System.Data.SqlClient.SqlCommand
2018
2019 $cmd.CommandText = "
2020 update Batches
2021 set datecaptured = @datecaptured, datecreated = @datecreated, numberdocs = @numberdocs,
2022 numberpages = @numberpages, programid = @programid, accountid = @accountid, boxid = @boxid,
2023 owner = @owner
2024 where batchid = @batchid
2025 "
2026
2027 $cmd.Parameters.Add("@batchid", [System.Data.SqlDbType]::Int) | Out-Null
2028 $cmd.Parameters["@batchid"].Value = $batch.ItemId
2029
2030 $cmd.Parameters.Add("@datecaptured", [System.Data.SqlDbType]::DateTime) | Out-Null
2031 $cmd.Parameters["@datecaptured"].Value = $batch.DateCaptured
2032
2033 $cmd.Parameters.Add("@datecreated", [System.Data.SqlDbType]::DateTime) | Out-Null
2034 $cmd.Parameters["@datecreated"].Value = ConvertTo-DbNull $batch.DateCreated
2035
2036 $cmd.Parameters.Add("@numberdocs", [System.Data.SqlDbType]::Int) | Out-Null
2037 $cmd.Parameters["@numberdocs"].Value = ConvertTo-DbNull $batch.NumberDocs
2038
2039 $cmd.Parameters.Add("@numberpages", [System.Data.SqlDbType]::Int) | Out-Null
2040 $cmd.Parameters["@numberpages"].Value = ConvertTo-DbNull $batch.NumberPages
2041
2042 $cmd.Parameters.Add("@programid", [System.Data.SqlDbType]::Int) | Out-Null
2043 $cmd.Parameters["@programid"].Value = $batch.ProgramId
2044
2045 $cmd.Parameters.Add("@accountid", [System.Data.SqlDbType]::Int) | Out-Null
2046 $cmd.Parameters["@accountid"].Value = $batch.AccountId
2047
2048 $cmd.Parameters.Add("@boxid", [System.Data.SqlDbType]::Int) | Out-Null
2049 $cmd.Parameters["@boxid"].Value = ConvertTo-DbNull $batch.BoxId
2050
2051 $cmd.Parameters.Add("@owner", [System.Data.SqlDbType]::Int) | Out-Null
2052 $cmd.Parameters["@owner"].Value = ConvertTo-DbNull $batch.Owner
2053
2054 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2055 $cmd = (ConvertTo-OracleCommand $cmd)
2056 }
2057
2058 $cmd.Connection = $dbConn
2059
2060 $rowsAffected = $cmd.ExecuteNonQuery()
2061
2062 return $rowsAffected
2063 }
2064 catch {
2065 throw ("Error in Update-Batch: " + $error[0])
2066 }
2067} # Update-Batch
2068
2069
2070Function Insert-Batch ($batch, $dbConn) {
2071 try {
2072 $cmd = New-Object System.Data.SqlClient.SqlCommand
2073
2074 $cmd.CommandText = "
2075 insert into Batches (
2076 batchid, datecaptured, datecreated, numberdocs, numberpages, programid,
2077 accountid, boxid, owner
2078 )
2079 values (
2080 @batchid, @datecaptured, @datecreated, @numberdocs, @numberpages, @programid,
2081 @accountid, @boxid, @owner
2082 )
2083 "
2084
2085 $cmd.Parameters.Add("@batchid", [System.Data.SqlDbType]::Int) | Out-Null
2086 $cmd.Parameters["@batchid"].Value = $batch.ItemId
2087
2088 $cmd.Parameters.Add("@datecaptured", [System.Data.SqlDbType]::DateTime) | Out-Null
2089 $cmd.Parameters["@datecaptured"].Value = $batch.DateCaptured
2090
2091 $cmd.Parameters.Add("@datecreated", [System.Data.SqlDbType]::DateTime) | Out-Null
2092 $cmd.Parameters["@datecreated"].Value = ConvertTo-DbNull $batch.DateCreated
2093
2094 $cmd.Parameters.Add("@numberdocs", [System.Data.SqlDbType]::Int) | Out-Null
2095 $cmd.Parameters["@numberdocs"].Value = ConvertTo-DbNull $batch.NumberDocs
2096
2097 $cmd.Parameters.Add("@numberpages", [System.Data.SqlDbType]::Int) | Out-Null
2098 $cmd.Parameters["@numberpages"].Value = ConvertTo-DbNull $batch.NumberPages
2099
2100 $cmd.Parameters.Add("@programid", [System.Data.SqlDbType]::Int) | Out-Null
2101 $cmd.Parameters["@programid"].Value = $batch.ProgramId
2102
2103 $cmd.Parameters.Add("@accountid", [System.Data.SqlDbType]::Int) | Out-Null
2104 $cmd.Parameters["@accountid"].Value = $batch.AccountId
2105
2106 $cmd.Parameters.Add("@boxid", [System.Data.SqlDbType]::Int) | Out-Null
2107 $cmd.Parameters["@boxid"].Value = ConvertTo-DbNull $batch.BoxId
2108
2109 $cmd.Parameters.Add("@owner", [System.Data.SqlDbType]::Int) | Out-Null
2110 $cmd.Parameters["@owner"].Value = ConvertTo-DbNull $batch.Owner
2111
2112 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2113 $cmd = (ConvertTo-OracleCommand $cmd)
2114 }
2115
2116 $cmd.Connection = $dbConn
2117
2118 $rowsAffected = $cmd.ExecuteNonQuery()
2119
2120 return $rowsAffected
2121 }
2122 catch {
2123 throw ("Error in Insert-Batch: " + $error[0])
2124 }
2125} # Insert-Batch
2126
2127
2128$global:diffQueries["BatchDetail_MasterNotAtSat"] = "
2129 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2130 select @satelliteid, 'BatchDetail', bd_mast.batchid, null, 'Unprocessed', @statustime
2131 from {MasterPrefix}BatchesDetail{MasterSuffix} bd_mast
2132 join {MasterPrefix}Batches{MasterSuffix} b_mast on b_mast.batchid = bd_mast.batchid
2133 where b_mast.owner = @satelliteid
2134 and not exists (
2135 select 1
2136 from {SatellitePrefix}BatchesDetail{SatelliteSuffix}
2137 where batchid = bd_mast.batchid
2138 )
2139"
2140
2141$global:diffQueries["BatchDetail_SatNotAtMaster"] = "
2142 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2143 select @satelliteid, 'BatchDetail', bd_sat.batchid, null, 'Unprocessed', @statustime
2144 from {SatellitePrefix}BatchesDetail{SatelliteSuffix} bd_sat
2145 where not exists (
2146 select 1
2147 from {MasterPrefix}BatchesDetail{MasterSuffix}
2148 where batchid = bd_sat.batchid
2149 )
2150"
2151
2152$global:diffQueries["BatchDetail_MasterSatDiff"] = "
2153 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2154 select @satelliteid, 'BatchDetail', bd_mast.batchid, null, 'Unprocessed', @statustime
2155 from {MasterPrefix}BatchesDetail{MasterSuffix} bd_mast
2156 join {MasterPrefix}Batches{MasterSuffix} b_mast on b_mast.batchid = bd_mast.batchid
2157 join {SatellitePrefix}BatchesDetail{SatelliteSuffix} bd_sat on bd_sat.batchid = bd_mast.batchid
2158 join {SatellitePrefix}Batches{SatelliteSuffix} b_sat on b_sat.batchid = bd_sat.batchid
2159 where bd_mast.machinename <> bd_sat.machinename
2160 or bd_mast.machinename is null and bd_sat.machinename is not null
2161 or bd_mast.machinename is not null and bd_sat.machinename is null
2162 or bd_mast.batchname <> bd_sat.batchname
2163 or bd_mast.batchname is null and bd_sat.batchname is not null
2164 or bd_mast.batchname is not null and bd_sat.batchname is null
2165"
2166
2167
2168Function Merge-BatchDetail ($detail1, $detail2) {
2169 try {
2170 $detail1.MachineName = Merge-Value $detail1.MachineName $detail2.MachineName "ReplaceNull"
2171 $detail1.BatchName = Merge-Value $detail1.BatchName $detail2.BatchName "ReplaceNull"
2172
2173 return $detail1
2174 }
2175 catch {
2176 throw ("Error in Merge-BatchDetail: " + $error[0])
2177 }
2178} # Merge-BatchDetail
2179
2180
2181# Create blank object once, so it can be copied to create new instances.
2182# This results in huge performance gains.
2183$global:blankBatchDetail = $global:blankItem.PSObject.Copy()
2184$global:blankBatchDetail.ItemType = "BatchDetail"
2185$global:blankBatchDetail | Add-Member NoteProperty MachineName $null
2186$global:blankBatchDetail | Add-Member NoteProperty BatchName $null
2187
2188Function Select-BatchDetail ($batchId, $dbConn) {
2189 try {
2190 $cmd = New-Object System.Data.SqlClient.SqlCommand
2191
2192 $cmd.CommandText = "
2193 select owner, machinename, batchname
2194 from BatchesDetail bd
2195 join Batches b on b.batchid = bd.batchid
2196 where bd.batchid = @batchid
2197 "
2198
2199 $cmd.Parameters.Add("@batchid", [System.Data.SqlDbType]::Int) | Out-Null
2200 $cmd.Parameters["@batchid"].Value = $batchId
2201
2202 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2203 $cmd = (ConvertTo-OracleCommand $cmd)
2204 }
2205
2206 $cmd.Connection = $dbConn
2207
2208 $reader = $cmd.ExecuteReader()
2209
2210 if ($reader.Read()) {
2211 $detail = $global:blankBatchDetail.PSObject.Copy()
2212
2213 $detail.ItemId = $batchId
2214 $detail.ItemId2 = $null
2215 $detail.Owner = ConvertTo-PsType $reader[0]
2216 $detail.MachineName = ConvertTo-PsType $reader[1]
2217 $detail.BatchName = ConvertTo-PsType $reader[2]
2218 }
2219 else {
2220 $detail = $null
2221 }
2222
2223 return $detail
2224 }
2225 catch {
2226 throw ("Error in Select-BatchDetail: " + $error[0])
2227 }
2228 finally {
2229 if ($reader) {$reader.Close()}
2230 }
2231} # Select-BatchDetail
2232
2233
2234Function Update-BatchDetail ($detail, $dbConn) {
2235 try {
2236 $cmd = New-Object System.Data.SqlClient.SqlCommand
2237
2238 $cmd.CommandText = "
2239 update BatchesDetail
2240 set machinename = @machinename, batchname = @batchname
2241 where batchid = @batchid
2242 "
2243
2244 $cmd.Parameters.Add("@batchid", [System.Data.SqlDbType]::Int) | Out-Null
2245 $cmd.Parameters["@batchid"].Value = $detail.ItemId
2246
2247 $cmd.Parameters.Add("@machinename", [System.Data.SqlDbType]::VarChar) | Out-Null
2248 $cmd.Parameters["@machinename"].Value = ConvertTo-DbNull $detail.MachineName
2249
2250 $cmd.Parameters.Add("@batchname", [System.Data.SqlDbType]::VarChar) | Out-Null
2251 $cmd.Parameters["@batchname"].Value = ConvertTo-DbNull $detail.BatchName
2252
2253 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2254 $cmd = (ConvertTo-OracleCommand $cmd)
2255 }
2256
2257 $cmd.Connection = $dbConn
2258
2259 $rowsAffected = $cmd.ExecuteNonQuery()
2260
2261 return $rowsAffected
2262 }
2263 catch {
2264 throw ("Error in Update-BatchDetail: " + $error[0])
2265 }
2266} # Update-BatchDetail
2267
2268
2269Function Insert-BatchDetail ($detail, $dbConn) {
2270 try {
2271 $cmd = New-Object System.Data.SqlClient.SqlCommand
2272
2273 $cmd.CommandText = "
2274 insert into BatchesDetail (batchid, machinename, batchname)
2275 values (@batchid, @machinename, @batchname)
2276 "
2277
2278 $cmd.Parameters.Add("@batchid", [System.Data.SqlDbType]::Int) | Out-Null
2279 $cmd.Parameters["@batchid"].Value = $detail.ItemId
2280
2281 $cmd.Parameters.Add("@machinename", [System.Data.SqlDbType]::VarChar) | Out-Null
2282 $cmd.Parameters["@machinename"].Value = ConvertTo-DbNull $detail.MachineName
2283
2284 $cmd.Parameters.Add("@batchname", [System.Data.SqlDbType]::VarChar) | Out-Null
2285 $cmd.Parameters["@batchname"].Value = ConvertTo-DbNull $detail.BatchName
2286
2287 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2288 $cmd = (ConvertTo-OracleCommand $cmd)
2289 }
2290
2291 $cmd.Connection = $dbConn
2292
2293 $rowsAffected = $cmd.ExecuteNonQuery()
2294
2295 return $rowsAffected
2296 }
2297 catch {
2298 throw ("Error in Insert-BatchDetail: " + $error[0])
2299 }
2300} # Insert-BatchDetail
2301
2302
2303$global:diffQueries["BoxInfo_MasterNotAtSat"] = "
2304 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2305 select @satelliteid, 'BoxInfo', bi_mast.boxid, null, 'Unprocessed', @statustime
2306 from {MasterPrefix}BoxInfo{MasterSuffix} bi_mast
2307 where bi_mast.owner = @satelliteid
2308 and not exists (
2309 select 1
2310 from {SatellitePrefix}BoxInfo{SatelliteSuffix}
2311 where boxid = bi_mast.boxid
2312 )
2313"
2314
2315$global:diffQueries["BoxInfo_SatNotAtMaster"] = "
2316 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2317 select @satelliteid, 'BoxInfo', bi_sat.boxid, null, 'Unprocessed', @statustime
2318 from {SatellitePrefix}BoxInfo{SatelliteSuffix} bi_sat
2319 where not exists (
2320 select 1
2321 from {MasterPrefix}BoxInfo{MasterSuffix}
2322 where boxid = bi_sat.boxid
2323 )
2324"
2325
2326$global:diffQueries["BoxInfo_MasterSatDiff"] = "
2327 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2328 select @satelliteid, 'BoxInfo', bi_mast.boxid, null, 'Unprocessed', @statustime
2329 from {MasterPrefix}BoxInfo{MasterSuffix} bi_mast
2330 join {SatellitePrefix}BoxInfo{SatelliteSuffix} bi_sat on bi_sat.boxid = bi_mast.boxid
2331 where bi_mast.boxnumber <> bi_sat.boxnumber
2332 or bi_mast.boxnumber is null and bi_sat.boxnumber is not null
2333 or bi_mast.boxnumber is not null and bi_sat.boxnumber is null
2334 or bi_mast.location <> bi_sat.location
2335 or bi_mast.location is null and bi_sat.location is not null
2336 or bi_mast.location is not null and bi_sat.location is null
2337 or bi_mast.datecreated <> bi_sat.datecreated
2338 or bi_mast.owner <> bi_sat.owner and bi_mast.owner in (0,@satelliteid) and bi_sat.owner in (0,@satelliteid)
2339 or bi_mast.owner is null and bi_sat.owner is not null
2340 or bi_mast.owner is not null and bi_sat.owner is null
2341"
2342
2343
2344Function Merge-BoxInfo ($boxInfo1, $boxInfo2) {
2345 try {
2346 $boxInfo1.BoxNumber = Merge-Value $boxInfo1.BoxNumber $boxInfo2.BoxNumber "ReplaceNull"
2347 $boxInfo1.Location = Merge-Value $boxInfo1.Location $boxInfo2.Location "ReplaceNull"
2348 $boxInfo1.DateCreated = Merge-Value $boxInfo1.DateCreated $boxInfo2.DateCreated "ReplaceNull" "Lesser"
2349 $boxInfo1.Owner = Merge-Value $boxInfo1.Owner $boxInfo2.Owner "ReplaceNull"
2350
2351 return $boxInfo1
2352 }
2353 catch {
2354 throw ("Error in Merge-BoxInfo: " + $error[0])
2355 }
2356} # Merge-BoxInfo
2357
2358
2359# Create blank object once, so it can be copied to create new instances.
2360# This results in huge performance gains.
2361$global:blankBoxInfo = $global:blankItem.PSObject.Copy()
2362$global:blankBoxInfo.ItemType = "BoxInfo"
2363$global:blankBoxInfo | Add-Member NoteProperty BoxNumber $null
2364$global:blankBoxInfo | Add-Member NoteProperty Location $null
2365$global:blankBoxInfo | Add-Member NoteProperty DateCreated $null
2366
2367
2368Function Select-BoxInfo ($boxId, $dbConn) {
2369 try {
2370 $cmd = New-Object System.Data.SqlClient.SqlCommand
2371
2372 $cmd.CommandText = "
2373 select owner, boxnumber, location, datecreated
2374 from BoxInfo
2375 where boxid = @boxid
2376 "
2377
2378 $cmd.Parameters.Add("@boxid", [System.Data.SqlDbType]::Int) | Out-Null
2379 $cmd.Parameters["@boxid"].Value = $boxId
2380
2381 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2382 $cmd = (ConvertTo-OracleCommand $cmd)
2383 }
2384
2385 $cmd.Connection = $dbConn
2386
2387 $reader = $cmd.ExecuteReader()
2388
2389 if ($reader.Read()) {
2390 $boxInfo = $global:blankBoxInfo.PSObject.Copy()
2391
2392 $boxInfo.ItemId = $boxId
2393 $boxInfo.ItemId2 = $null
2394 $boxInfo.Owner = ConvertTo-PsType $reader[0]
2395 $boxInfo.BoxNumber = ConvertTo-PsType $reader[1]
2396 $boxInfo.Location = ConvertTo-PsType $reader[2]
2397 $boxInfo.DateCreated = ConvertTo-PsType $reader[3]
2398 }
2399 else {
2400 $boxInfo = $null
2401 }
2402
2403 return $boxInfo
2404 }
2405 catch {
2406 throw ("Error in Select-BoxInfo: " + $error[0])
2407 }
2408 finally {
2409 if ($reader) {$reader.Close()}
2410 }
2411} # Select-BoxInfo
2412
2413
2414Function Update-BoxInfo ($boxInfo, $dbConn) {
2415 try {
2416 $cmd = New-Object System.Data.SqlClient.SqlCommand
2417
2418 $cmd.CommandText = "
2419 update BoxInfo
2420 set boxnumber = @boxnumber, location = @location, datecreated = @datecreated, owner = @owner
2421 where boxid = @boxid
2422 "
2423
2424 $cmd.Parameters.Add("@boxid", [System.Data.SqlDbType]::Int) | Out-Null
2425 $cmd.Parameters["@boxid"].Value = $boxInfo.ItemId
2426
2427 $cmd.Parameters.Add("@boxnumber", [System.Data.SqlDbType]::VarChar) | Out-Null
2428 $cmd.Parameters["@boxnumber"].Value = ConvertTo-DbNull $boxInfo.BoxNumber
2429
2430 $cmd.Parameters.Add("@location", [System.Data.SqlDbType]::VarChar) | Out-Null
2431 $cmd.Parameters["@location"].Value = ConvertTo-DbNull $boxInfo.Location
2432
2433 $cmd.Parameters.Add("@datecreated", [System.Data.SqlDbType]::DateTime) | Out-Null
2434 $cmd.Parameters["@datecreated"].Value = $boxInfo.DateCreated
2435
2436 $cmd.Parameters.Add("@owner", [System.Data.SqlDbType]::Int) | Out-Null
2437 $cmd.Parameters["@owner"].Value = ConvertTo-DbNull $boxInfo.Owner
2438
2439 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2440 $cmd = (ConvertTo-OracleCommand $cmd)
2441 }
2442
2443 $cmd.Connection = $dbConn
2444
2445 $rowsAffected = $cmd.ExecuteNonQuery()
2446
2447 return $rowsAffected
2448 }
2449 catch {
2450 throw ("Error in Update-BoxInfo: " + $error[0])
2451 }
2452} # Update-BoxInfo
2453
2454
2455Function Insert-BoxInfo ($boxInfo, $dbConn) {
2456 try {
2457 $cmd = New-Object System.Data.SqlClient.SqlCommand
2458
2459 $cmd.CommandText = "
2460 insert into BoxInfo (boxid, boxnumber, location, datecreated, owner)
2461 values (@boxid, @boxnumber, @location, @datecreated, @owner)
2462 "
2463
2464 $cmd.Parameters.Add("@boxid", [System.Data.SqlDbType]::Int) | Out-Null
2465 $cmd.Parameters["@boxid"].Value = $boxInfo.ItemId
2466
2467 $cmd.Parameters.Add("@boxnumber", [System.Data.SqlDbType]::VarChar) | Out-Null
2468 $cmd.Parameters["@boxnumber"].Value = ConvertTo-DbNull $boxInfo.BoxNumber
2469
2470 $cmd.Parameters.Add("@location", [System.Data.SqlDbType]::VarChar) | Out-Null
2471 $cmd.Parameters["@location"].Value = ConvertTo-DbNull $boxInfo.Location
2472
2473 $cmd.Parameters.Add("@datecreated", [System.Data.SqlDbType]::DateTime) | Out-Null
2474 $cmd.Parameters["@datecreated"].Value = $boxInfo.DateCreated
2475
2476 $cmd.Parameters.Add("@owner", [System.Data.SqlDbType]::Int) | Out-Null
2477 $cmd.Parameters["@owner"].Value = ConvertTo-DbNull $boxInfo.Owner
2478
2479 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2480 $cmd = (ConvertTo-OracleCommand $cmd)
2481 }
2482
2483 $cmd.Connection = $dbConn
2484
2485 $rowsAffected = $cmd.ExecuteNonQuery()
2486
2487 return $rowsAffected
2488 }
2489 catch {
2490 throw ("Error in Insert-BoxInfo: " + $error[0])
2491 }
2492} # Insert-BoxInfo
2493
2494
2495$global:diffQueries["DocFolder_MasterNotAtSat"] = "
2496 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2497 select @satelliteid, 'DocFolder', df_mast.docfolderid, null, 'Unprocessed', @statustime
2498 from {MasterPrefix}DocFolder{MasterSuffix} df_mast
2499 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
2500 where f_mast.owner = @satelliteid
2501 and not exists (
2502 select 1
2503 from {SatellitePrefix}DocFolder{SatelliteSuffix}
2504 where docfolderid = df_mast.docfolderid
2505 )
2506"
2507
2508$global:diffQueries["DocFolder_SatNotAtMaster"] = "
2509 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2510 select @satelliteid, 'DocFolder', df_sat.docfolderid, null, 'Unprocessed', @statustime
2511 from {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat
2512 where not exists (
2513 select 1
2514 from {MasterPrefix}DocFolder{MasterSuffix}
2515 where docfolderid = df_sat.docfolderid
2516 )
2517"
2518
2519$global:diffQueries["DocFolder_MasterSatDiff"] = "
2520 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2521 select @satelliteid, 'DocFolder', df_mast.docfolderid, null, 'Unprocessed', @statustime
2522 from {MasterPrefix}DocFolder{MasterSuffix} df_mast
2523 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
2524 join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = df_mast.docfolderid
2525 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = df_sat.fileid
2526 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
2527 and (
2528 df_mast.parentid <> df_sat.parentid
2529 or df_mast.parentid is null and df_sat.parentid is not null
2530 or df_mast.parentid is not null and df_sat.parentid is null
2531 or df_mast.description <> df_sat.description
2532 or df_mast.lastmodified <> df_sat.lastmodified
2533 or df_mast.fileid <> df_sat.fileid
2534 or df_mast.created <> df_sat.created
2535 or df_mast.isdeleted <> df_sat.isdeleted
2536 or cast(df_mast.permissions as varbinary(max)) <> cast(df_sat.permissions as varbinary(max))
2537 or df_mast.permissions is null and df_sat.permissions is not null
2538 or df_mast.permissions is not null and df_sat.permissions is null
2539 )
2540"
2541
2542
2543Function Merge-DocFolder ($docFolder1, $docFolder2) {
2544 try {
2545 $docFolder1.LastModified = Merge-Value $docFolder1.LastModified $docFolder2.LastModified "ReplaceNull" "Greater"
2546 $docFolder1.Created = Merge-Value $docFolder1.Created $docFolder2.Created "ReplaceNull" "Lesser"
2547
2548 return $docFolder1
2549 }
2550 catch {
2551 throw ("Error in Merge-DocFolder: " + $error[0])
2552 }
2553} # Merge-DocFolder
2554
2555
2556# Create blank object once, so it can be copied to create new instances.
2557# This results in huge performance gains.
2558$global:blankDocFolder = $global:blankItem.PSObject.Copy()
2559$global:blankDocFolder.ItemType = "DocFolder"
2560$global:blankDocFolder | Add-Member NoteProperty ParentId $null
2561$global:blankDocFolder | Add-Member NoteProperty Description $null
2562$global:blankDocFolder | Add-Member NoteProperty LastModified $null
2563$global:blankDocFolder | Add-Member NoteProperty FileId $null
2564$global:blankDocFolder | Add-Member NoteProperty Created $null
2565$global:blankDocFolder | Add-Member NoteProperty Permissions $null
2566$global:blankDocFolder | Add-Member NoteProperty IsDeleted $null
2567
2568
2569Function Select-DocFolder ($docFolderId, $dbConn) {
2570 try {
2571 $cmd = New-Object System.Data.SqlClient.SqlCommand
2572
2573 $cmd.CommandText = "
2574 select f.owner, df.parentid, df.description, df.lastmodified, df.fileid, df.created,
2575 df.permissions, df.isdeleted
2576 from DocFolder df
2577 join Files f on f.fileid = df.fileid
2578 where df.docfolderid = @docfolderid
2579 "
2580
2581 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
2582 $cmd.Parameters["@docfolderid"].Value = $docFolderId
2583
2584 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2585 $cmd = (ConvertTo-OracleCommand $cmd)
2586 }
2587
2588 $cmd.Connection = $dbConn
2589
2590 $reader = $cmd.ExecuteReader()
2591
2592 if ($reader.Read()) {
2593 $docFolder = $global:blankDocFolder.PSObject.Copy()
2594
2595 $docFolder.ItemId = $docFolderId
2596 $docFolder.ItemId2 = $null
2597 $docFolder.Owner = ConvertTo-PsType $reader[0]
2598 $docFolder.ParentId = ConvertTo-PsType $reader[1]
2599 $docFolder.Description = ConvertTo-PsType $reader[2]
2600 $docFolder.LastModified = ConvertTo-PsType $reader[3]
2601 $docFolder.FileId = ConvertTo-PsType $reader[4]
2602 $docFolder.Created = ConvertTo-PsType $reader[5]
2603 $docFolder.Permissions = ConvertTo-PsType $reader[6]
2604 $docFolder.IsDeleted = ConvertTo-PsType $reader[7]
2605 }
2606 else {
2607 $docFolder = $null
2608 }
2609
2610 return $docFolder
2611 }
2612 catch {
2613 throw ("Error in Select-DocFolder: " + $error[0])
2614 }
2615 finally {
2616 if ($reader) {$reader.Close()}
2617 }
2618} # Select-DocFolder
2619
2620
2621Function Update-DocFolder ($docFolder, $dbConn) {
2622 try {
2623 $cmd = New-Object System.Data.SqlClient.SqlCommand
2624
2625 $cmd.CommandText = "
2626 update DocFolder
2627 set parentid = @parentid, description = @description, lastmodified = @lastmodified,
2628 fileid = @fileid, created = @created, permissions = @permissions, isdeleted = @isdeleted
2629 where docfolderid = @docfolderid
2630 "
2631
2632 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
2633 $cmd.Parameters["@docfolderid"].Value = $docFolder.ItemId
2634
2635 $cmd.Parameters.Add("@parentid", [System.Data.SqlDbType]::Int) | Out-Null
2636 $cmd.Parameters["@parentid"].Value = ConvertTo-DbNull $docFolder.ParentId
2637
2638 $cmd.Parameters.Add("@description", [System.Data.SqlDbType]::VarChar) | Out-Null
2639 $cmd.Parameters["@description"].Value = $docFolder.Description
2640
2641 $cmd.Parameters.Add("@lastmodified", [System.Data.SqlDbType]::DateTime) | Out-Null
2642 $cmd.Parameters["@lastmodified"].Value = $docFolder.LastModified
2643
2644 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
2645 $cmd.Parameters["@fileid"].Value = $docFolder.FileId
2646
2647 $cmd.Parameters.Add("@created", [System.Data.SqlDbType]::DateTime) | Out-Null
2648 $cmd.Parameters["@created"].Value = $docFolder.Created
2649
2650 $cmd.Parameters.Add("@permissions", [System.Data.SqlDbType]::Image) | Out-Null
2651 if ($docFolder.Permissions -ne $null) {$cmd.Parameters["@permissions"].Value = [byte[]]$docFolder.Permissions}
2652 else {$cmd.Parameters["@permissions"].Value = (ConvertTo-DbNull $docFolder.Permissions)}
2653
2654 $cmd.Parameters.Add("@isdeleted", [System.Data.SqlDbType]::Int) | Out-Null
2655 $cmd.Parameters["@isdeleted"].Value = $docFolder.IsDeleted
2656
2657 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2658 $cmd = (ConvertTo-OracleCommand $cmd)
2659
2660 if ($docFolder.Description -eq "") {$cmd.Parameters["@description"].Value = " "}
2661 }
2662
2663 $cmd.Connection = $dbConn
2664
2665 $rowsAffected = $cmd.ExecuteNonQuery()
2666
2667 return $rowsAffected
2668 }
2669 catch {
2670 throw ("Error in Update-DocFolder: " + $error[0])
2671 }
2672} # Update-DocFolder
2673
2674
2675Function Insert-DocFolder ($docFolder, $dbConn) {
2676 try {
2677 $cmd = New-Object System.Data.SqlClient.SqlCommand
2678
2679 $cmd.CommandText = "
2680 insert into DocFolder (
2681 docfolderid, parentid, description, lastmodified, fileid, created,
2682 permissions, isdeleted
2683 )
2684 values (
2685 @docfolderid, @parentid, @description, @lastmodified, @fileid, @created,
2686 @permissions, @isdeleted
2687 )
2688 "
2689
2690 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
2691 $cmd.Parameters["@docfolderid"].Value = $docFolder.ItemId
2692
2693 $cmd.Parameters.Add("@parentid", [System.Data.SqlDbType]::Int) | Out-Null
2694 $cmd.Parameters["@parentid"].Value = ConvertTo-DbNull $docFolder.ParentId
2695
2696 $cmd.Parameters.Add("@description", [System.Data.SqlDbType]::VarChar) | Out-Null
2697 $cmd.Parameters["@description"].Value = $docFolder.Description
2698
2699 $cmd.Parameters.Add("@lastmodified", [System.Data.SqlDbType]::DateTime) | Out-Null
2700 $cmd.Parameters["@lastmodified"].Value = $docFolder.LastModified
2701
2702 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
2703 $cmd.Parameters["@fileid"].Value = $docFolder.FileId
2704
2705 $cmd.Parameters.Add("@created", [System.Data.SqlDbType]::DateTime) | Out-Null
2706 $cmd.Parameters["@created"].Value = $docFolder.Created
2707
2708 $cmd.Parameters.Add("@permissions", [System.Data.SqlDbType]::Image) | Out-Null
2709 if ($docFolder.Permissions -ne $null) {$cmd.Parameters["@permissions"].Value = [byte[]]$docFolder.Permissions}
2710 else {$cmd.Parameters["@permissions"].Value = (ConvertTo-DbNull $docFolder.Permissions)}
2711
2712 $cmd.Parameters.Add("@isdeleted", [System.Data.SqlDbType]::Int) | Out-Null
2713 $cmd.Parameters["@isdeleted"].Value = $docFolder.IsDeleted
2714
2715 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2716 $cmd = (ConvertTo-OracleCommand $cmd)
2717
2718 if ($docFolder.Description -eq "") {$cmd.Parameters["@description"].Value = " "}
2719 }
2720
2721 $cmd.Connection = $dbConn
2722
2723 $rowsAffected = $cmd.ExecuteNonQuery()
2724
2725 return $rowsAffected
2726 }
2727 catch {
2728 throw ("Error in Insert-DocFolder: " + $error[0])
2729 }
2730} # Insert-DocFolder
2731
2732
2733$global:diffQueries["Document_MasterNotAtSat"] = "
2734 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2735 select @satelliteid, 'Document', d_mast.docfolderid, null, 'Unprocessed', @statustime
2736 from {MasterPrefix}Document{MasterSuffix} d_mast
2737 join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = d_mast.docfolderid
2738 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
2739 where f_mast.owner = @satelliteid
2740 and not exists (
2741 select 1
2742 from {SatellitePrefix}Document{SatelliteSuffix}
2743 where docfolderid = d_mast.docfolderid
2744 )
2745"
2746
2747$global:diffQueries["Document_SatNotAtMaster"] = "
2748 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2749 select @satelliteid, 'Document', d_sat.docfolderid, null, 'Unprocessed', @statustime
2750 from {SatellitePrefix}Document{SatelliteSuffix} d_sat
2751 where not exists (
2752 select 1
2753 from {MasterPrefix}Document{MasterSuffix}
2754 where docfolderid = d_sat.docfolderid
2755 )
2756"
2757
2758$global:diffQueries["Document_MasterSatDiff"] = "
2759 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2760 select @satelliteid, 'Document', d_mast.docfolderid, null, 'Unprocessed', @statustime
2761 from {MasterPrefix}Document{MasterSuffix} d_mast
2762 join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = d_mast.docfolderid
2763 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
2764 join {SatellitePrefix}Document{SatelliteSuffix} d_sat on d_sat.docfolderid = d_mast.docfolderid
2765 join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = d_sat.docfolderid
2766 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = df_sat.fileid
2767 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
2768 and (
2769 d_mast.pagecount <> d_sat.pagecount
2770 or d_mast.documentdate <> d_sat.documentdate
2771 )
2772"
2773
2774
2775Function Merge-Document ($document1, $document2) {
2776 try {
2777
2778
2779 return $document1
2780 }
2781 catch {
2782 throw ("Error in Merge-Document: " + $error[0])
2783 }
2784} # Merge-Document
2785
2786
2787# Create blank object once, so it can be copied to create new instances.
2788# This results in huge performance gains.
2789$global:blankDocument = $global:blankItem.PSObject.Copy()
2790$global:blankDocument.ItemType = "Document"
2791$global:blankDocument | Add-Member NoteProperty PageCount $null
2792$global:blankDocument | Add-Member NoteProperty DocumentDate $null
2793
2794
2795
2796Function Select-Document ($docFolderId, $dbConn) {
2797 try {
2798 $cmd = New-Object System.Data.SqlClient.SqlCommand
2799
2800 $cmd.CommandText = "
2801 select f.owner, d.pagecount, d.documentdate
2802 from Document d
2803 join DocFolder df on df.docfolderid = d.docfolderid
2804 join Files f on f.fileid = df.fileid
2805 where d.docfolderid = @docfolderid
2806 "
2807
2808 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
2809 $cmd.Parameters["@docfolderid"].Value = $docFolderId
2810
2811 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2812 $cmd = (ConvertTo-OracleCommand $cmd)
2813 }
2814
2815 $cmd.Connection = $dbConn
2816
2817 $reader = $cmd.ExecuteReader()
2818
2819 if ($reader.Read()) {
2820 $document = $global:blankDocument.PSObject.Copy()
2821
2822 $document.ItemId = $docFolderId
2823 $document.ItemId2 = $null
2824 $document.Owner = ConvertTo-PsType $reader[0]
2825 $document.PageCount = ConvertTo-PsType $reader[1]
2826 $document.DocumentDate = ConvertTo-PsType $reader[2]
2827
2828 }
2829 else {
2830 $document = $null
2831 }
2832
2833 return $document
2834 }
2835 catch {
2836 throw ("Error in Select-Document: " + $error[0])
2837 }
2838 finally {
2839 if ($reader) {$reader.Close()}
2840 }
2841} # Select-Document
2842
2843
2844Function Update-Document ($document, $dbConn) {
2845 try {
2846 $cmd = New-Object System.Data.SqlClient.SqlCommand
2847
2848 $cmd.CommandText = "
2849 update Document
2850 set pagecount = @pagecount, documentdate = @documentdate
2851 where docfolderid = @docfolderid
2852 "
2853
2854 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
2855 $cmd.Parameters["@docfolderid"].Value = $document.ItemId
2856
2857 $cmd.Parameters.Add("@pagecount", [System.Data.SqlDbType]::Int) | Out-Null
2858 $cmd.Parameters["@pagecount"].Value = $document.PageCount
2859
2860 $cmd.Parameters.Add("@documentdate", [System.Data.SqlDbType]::DateTime) | Out-Null
2861 $cmd.Parameters["@documentdate"].Value = $document.DocumentDate
2862
2863
2864 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2865 $cmd = (ConvertTo-OracleCommand $cmd)
2866 }
2867
2868 $cmd.Connection = $dbConn
2869
2870 $rowsAffected = $cmd.ExecuteNonQuery()
2871
2872 return $rowsAffected
2873 }
2874 catch {
2875 throw ("Error in Update-Document: " + $error[0])
2876 }
2877} # Update-Document
2878
2879
2880Function Insert-Document ($document, $dbConn) {
2881 try {
2882 $cmd = New-Object System.Data.SqlClient.SqlCommand
2883
2884 $cmd.CommandText = "
2885 insert into Document (docfolderid, pagecount, documentdate)
2886 values (@docfolderid, @pagecount, @documentdate)
2887 "
2888
2889 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
2890 $cmd.Parameters["@docfolderid"].Value = $document.ItemId
2891
2892 $cmd.Parameters.Add("@pagecount", [System.Data.SqlDbType]::Int) | Out-Null
2893 $cmd.Parameters["@pagecount"].Value = $document.PageCount
2894
2895 $cmd.Parameters.Add("@documentdate", [System.Data.SqlDbType]::DateTime) | Out-Null
2896 $cmd.Parameters["@documentdate"].Value = $document.DocumentDate
2897
2898
2899 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
2900 $cmd = (ConvertTo-OracleCommand $cmd)
2901 }
2902
2903 $cmd.Connection = $dbConn
2904
2905 $rowsAffected = $cmd.ExecuteNonQuery()
2906
2907 return $rowsAffected
2908 }
2909 catch {
2910 throw ("Error in Insert-Document: " + $error[0])
2911 }
2912} # Insert-Document
2913
2914
2915$global:diffQueries["File_MasterNotAtSat"] = "
2916 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2917 select @satelliteid, 'File', f_mast.fileid, null, 'Unprocessed', @statustime
2918 from {MasterPrefix}Files{MasterSuffix} f_mast
2919 where f_mast.owner = @satelliteid
2920 and not exists (
2921 select 1
2922 from {SatellitePrefix}Files{SatelliteSuffix}
2923 where fileid = f_mast.fileid
2924 )
2925"
2926
2927$global:diffQueries["File_SatNotAtMaster"] = "
2928 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2929 select @satelliteid, 'File', f_sat.fileid, null, 'Unprocessed', @statustime
2930 from {SatellitePrefix}Files{SatelliteSuffix} f_sat
2931 where not exists (
2932 select 1
2933 from {MasterPrefix}Files{MasterSuffix}
2934 where fileid = f_sat.fileid
2935 )
2936"
2937
2938$global:diffQueries["File_MasterSatDiff"] = "
2939 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
2940 select @satelliteid, 'File', f_mast.fileid, null, 'Unprocessed', @statustime
2941 from {MasterPrefix}Files{MasterSuffix} f_mast
2942 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = f_mast.fileid
2943 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
2944 and (
2945 f_mast.filenumber <> f_sat.filenumber
2946 or f_mast.filejacket <> f_sat.filejacket
2947 or f_mast.filejacket is null and f_sat.filejacket is not null
2948 or f_mast.filejacket is not null and f_sat.filejacket is null
2949 or f_mast.filename <> f_sat.filename
2950 or f_mast.filenumber2 <> f_sat.filenumber2
2951 or f_mast.owner <> f_sat.owner
2952 or f_mast.owner is null and f_sat.owner is not null
2953 or f_mast.owner is not null and f_sat.owner is null
2954 or f_mast.locationid <> f_sat.locationid
2955 or f_mast.lastmodified <> f_sat.lastmodified
2956 or f_mast.lastmodified is null and f_sat.lastmodified is not null
2957 or f_mast.lastmodified is not null and f_sat.lastmodified is null
2958 or f_mast.created <> f_sat.created
2959 or f_mast.datelastopened <> f_sat.datelastopened
2960 or f_mast.datelastopened is null and f_sat.datelastopened is not null
2961 or f_mast.datelastopened is not null and f_sat.datelastopened is null
2962 or f_mast.isdeleted <> f_sat.isdeleted
2963 or f_mast.istemporary <> f_sat.istemporary
2964 or f_mast.isheld <> f_sat.isheld
2965 or f_mast.isfrozen <> f_sat.isfrozen
2966 or cast(f_mast.permissions as varbinary(max)) <> cast(f_sat.permissions as varbinary(max))
2967 or f_mast.permissions is null and f_sat.permissions is not null
2968 or f_mast.permissions is not null and f_sat.permissions is null
2969 )
2970"
2971
2972
2973Function Merge-File ($file1, $file2) {
2974 try {
2975 $file1.Owner = Merge-Value $file1.Owner $file2.Owner "ReplaceNull"
2976 $file1.LastModified = Merge-Value $file1.LastModified $file2.LastModified "ReplaceNull" "Greater"
2977 $file1.Created = Merge-Value $file1.Created $file2.Created "ReplaceNull" "Lesser"
2978 $file1.DateLastOpened = Merge-Value $file1.DateLastOpened $file2.DateLastOpened "ReplaceNull" "Greater"
2979
2980 return $file1
2981 }
2982 catch {
2983 throw ("Error in Merge-File: " + $error[0])
2984 }
2985} # Merge-File
2986
2987
2988# Create blank object once, so it can be copied to create new instances.
2989# This results in huge performance gains.
2990$global:blankFile = $global:blankItem.PSObject.Copy()
2991$global:blankFile.ItemType = "File"
2992$global:blankFile | Add-Member NoteProperty FileNumber $null
2993$global:blankFile | Add-Member NoteProperty FileJacket $null
2994$global:blankFile | Add-Member NoteProperty FileName $null
2995$global:blankFile | Add-Member NoteProperty FileNumber2 $null
2996$global:blankFile | Add-Member NoteProperty FileNumber3 $null
2997$global:blankFile | Add-Member NoteProperty Locked $null
2998$global:blankFile | Add-Member NoteProperty LockExpiration $null
2999$global:blankFile | Add-Member NoteProperty LocationId $null
3000$global:blankFile | Add-Member NoteProperty LastModified $null
3001$global:blankFile | Add-Member NoteProperty Permissions $null
3002$global:blankFile | Add-Member NoteProperty Created $null
3003$global:blankFile | Add-Member NoteProperty DateLastOpened $null
3004$global:blankFile | Add-Member NoteProperty IsDeleted $null
3005$global:blankFile | Add-Member NoteProperty IsTemporary $null
3006$global:blankFile | Add-Member NoteProperty IsHeld $null
3007$global:blankFile | Add-Member NoteProperty IsFrozen $null
3008
3009
3010Function Select-File ($fileId, $dbConn) {
3011 try {
3012 $cmd = New-Object System.Data.SqlClient.SqlCommand
3013
3014 $cmd.CommandText = "
3015 select owner, filenumber, filejacket, filename, filenumber2, filenumber3, locked,
3016 lockexpiration, locationid, lastmodified, permissions, created, datelastopened, isdeleted,
3017 istemporary, isheld, isfrozen
3018 from Files
3019 where fileid = @fileid
3020 "
3021
3022 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
3023 $cmd.Parameters["@fileid"].Value = $fileId
3024
3025 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3026 $cmd = (ConvertTo-OracleCommand $cmd)
3027 }
3028
3029 $cmd.Connection = $dbConn
3030
3031 $reader = $cmd.ExecuteReader()
3032
3033 if ($reader.Read()) {
3034 $file = $global:blankFile.PSObject.Copy()
3035
3036 $file.ItemId = $fileId
3037 $file.ItemId2 = $null
3038 $file.Owner = ConvertTo-PsType $reader[0]
3039 $file.FileNumber = ConvertTo-PsType $reader[1]
3040 $file.FileJacket = ConvertTo-PsType $reader[2]
3041 $file.FileName = ConvertTo-PsType $reader[3]
3042 $file.FileNumber2 = ConvertTo-PsType $reader[4]
3043 $file.FileNumber3 = ConvertTo-PsType $reader[5]
3044 $file.Locked = ConvertTo-PsType $reader[6]
3045 $file.LockExpiration = ConvertTo-PsType $reader[7]
3046 $file.LocationId = ConvertTo-PsType $reader[8]
3047 $file.LastModified = ConvertTo-PsType $reader[9]
3048 $file.Permissions = ConvertTo-PsType $reader[10]
3049 $file.Created = ConvertTo-PsType $reader[11]
3050 $file.DateLastOpened = ConvertTo-PsType $reader[12]
3051 $file.IsDeleted = ConvertTo-PsType $reader[13]
3052 $file.IsTemporary = ConvertTo-PsType $reader[14]
3053 $file.IsHeld = ConvertTo-PsType $reader[15]
3054 $file.IsFrozen = ConvertTo-PsType $reader[16]
3055 }
3056 else {
3057 $file = $null
3058 }
3059
3060 return $file
3061 }
3062 catch {
3063 throw ("Error in Select-File: " + $error[0])
3064 }
3065 finally {
3066 if ($reader) {$reader.Close()}
3067 }
3068} # Select-File
3069
3070
3071Function Update-File ($file, $dbConn) {
3072 try {
3073 $cmd = New-Object System.Data.SqlClient.SqlCommand
3074
3075 $cmd.CommandText = "
3076 update Files
3077 set filenumber = @filenumber, filejacket = @filejacket, filename = @filename,
3078 filenumber2 = @filenumber2, owner = @owner, filenumber3 = @filenumber3, locked = @locked,
3079 lockexpiration = @lockexpiration, locationid = @locationid, lastmodified = @lastmodified,
3080 permissions = @permissions, created = @created, datelastopened = @datelastopened,
3081 isdeleted = @isdeleted, istemporary = @istemporary, isheld = @isheld, isfrozen = @isfrozen
3082 where fileid = @fileid
3083 "
3084
3085 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
3086 $cmd.Parameters["@fileid"].Value = $file.ItemId
3087
3088 $cmd.Parameters.Add("@filenumber", [System.Data.SqlDbType]::VarChar) | Out-Null
3089 $cmd.Parameters["@filenumber"].Value = $file.FileNumber
3090
3091 $cmd.Parameters.Add("@filejacket", [System.Data.SqlDbType]::Int) | Out-Null
3092 $cmd.Parameters["@filejacket"].Value = ConvertTo-DbNull $file.FileJacket
3093
3094 $cmd.Parameters.Add("@filename", [System.Data.SqlDbType]::VarChar) | Out-Null
3095 $cmd.Parameters["@filename"].Value = $file.FileName
3096
3097 $cmd.Parameters.Add("@filenumber2", [System.Data.SqlDbType]::VarChar) | Out-Null
3098 $cmd.Parameters["@filenumber2"].Value = $file.FileNumber2
3099
3100 $cmd.Parameters.Add("@owner", [System.Data.SqlDbType]::Int) | Out-Null
3101 $cmd.Parameters["@owner"].Value = ConvertTo-DbNull $file.Owner
3102
3103 $cmd.Parameters.Add("@filenumber3", [System.Data.SqlDbType]::VarChar) | Out-Null
3104 $cmd.Parameters["@filenumber3"].Value = $file.FileNumber3
3105
3106 $cmd.Parameters.Add("@locked", [System.Data.SqlDbType]::Int) | Out-Null
3107 $cmd.Parameters["@locked"].Value = ConvertTo-DbNull $file.Locked
3108
3109 $cmd.Parameters.Add("@lockexpiration", [System.Data.SqlDbType]::DateTime) | Out-Null
3110 $cmd.Parameters["@lockexpiration"].Value = ConvertTo-DbNull $file.LockExpiration
3111
3112 $cmd.Parameters.Add("@locationid", [System.Data.SqlDbType]::Int) | Out-Null
3113 $cmd.Parameters["@locationid"].Value = $file.LocationId
3114
3115 $cmd.Parameters.Add("@lastmodified", [System.Data.SqlDbType]::DateTime) | Out-Null
3116 $cmd.Parameters["@lastmodified"].Value = ConvertTo-DbNull $file.LastModified
3117
3118 $cmd.Parameters.Add("@permissions", [System.Data.SqlDbType]::Image) | Out-Null
3119 if ($file.Permissions -ne $null) {$cmd.Parameters["@permissions"].Value = [byte[]]$file.Permissions}
3120 else {$cmd.Parameters["@permissions"].Value = (ConvertTo-DbNull $file.Permissions)}
3121
3122 $cmd.Parameters.Add("@created", [System.Data.SqlDbType]::DateTime) | Out-Null
3123 $cmd.Parameters["@created"].Value = $file.Created
3124
3125 $cmd.Parameters.Add("@datelastopened", [System.Data.SqlDbType]::DateTime) | Out-Null
3126 $cmd.Parameters["@datelastopened"].Value = ConvertTo-DbNull $file.DateLastOpened
3127
3128 $cmd.Parameters.Add("@isdeleted", [System.Data.SqlDbType]::Int) | Out-Null
3129 $cmd.Parameters["@isdeleted"].Value = $file.IsDeleted
3130
3131 $cmd.Parameters.Add("@istemporary", [System.Data.SqlDbType]::Int) | Out-Null
3132 $cmd.Parameters["@istemporary"].Value = $file.IsTemporary
3133
3134 $cmd.Parameters.Add("@isheld", [System.Data.SqlDbType]::Int) | Out-Null
3135 $cmd.Parameters["@isheld"].Value = ConvertTo-DbNull $file.IsHeld
3136
3137 $cmd.Parameters.Add("@isfrozen", [System.Data.SqlDbType]::Int) | Out-Null
3138 $cmd.Parameters["@isfrozen"].Value = ConvertTo-DbNull $file.IsFrozen
3139
3140 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3141 $cmd = (ConvertTo-OracleCommand $cmd)
3142
3143 if ($file.FileNumber -eq "") {$cmd.Parameters["@filenumber"].Value = " "}
3144 if ($file.FileNumber2 -eq "") {$cmd.Parameters["@filenumber2"].Value = " "}
3145 if ($file.FileNumber3 -eq "") {$cmd.Parameters["@filenumber3"].Value = " "}
3146 }
3147
3148 $cmd.Connection = $dbConn
3149
3150 $rowsAffected = $cmd.ExecuteNonQuery()
3151
3152 return $rowsAffected
3153 }
3154 catch {
3155 throw ("Error in Update-File: " + $error[0])
3156 }
3157} # Update-File
3158
3159
3160Function Insert-File ($file, $dbConn) {
3161 try {
3162 $cmd = New-Object System.Data.SqlClient.SqlCommand
3163
3164 $cmd.CommandText = "
3165 insert into Files (
3166 filenumber, filejacket, filename, filenumber2, owner, filenumber3, locked,
3167 lockexpiration, locationid, fileid, lastmodified, permissions, created,
3168 datelastopened, isdeleted, istemporary, isheld, isfrozen
3169 )
3170 values (
3171 @filenumber, @filejacket, @filename, @filenumber2, @owner, @filenumber3, @locked,
3172 @lockexpiration, @locationid, @fileid, @lastmodified, @permissions, @created,
3173 @datelastopened, @isdeleted, @istemporary, @isheld, @isfrozen
3174 )
3175 "
3176
3177 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
3178 $cmd.Parameters["@fileid"].Value = $file.ItemId
3179
3180 $cmd.Parameters.Add("@filenumber", [System.Data.SqlDbType]::VarChar) | Out-Null
3181 $cmd.Parameters["@filenumber"].Value = $file.FileNumber
3182
3183 $cmd.Parameters.Add("@filejacket", [System.Data.SqlDbType]::Int) | Out-Null
3184 $cmd.Parameters["@filejacket"].Value = ConvertTo-DbNull $file.FileJacket
3185
3186 $cmd.Parameters.Add("@filename", [System.Data.SqlDbType]::VarChar) | Out-Null
3187 $cmd.Parameters["@filename"].Value = $file.FileName
3188
3189 $cmd.Parameters.Add("@filenumber2", [System.Data.SqlDbType]::VarChar) | Out-Null
3190 $cmd.Parameters["@filenumber2"].Value = $file.FileNumber2
3191
3192 $cmd.Parameters.Add("@owner", [System.Data.SqlDbType]::Int) | Out-Null
3193 $cmd.Parameters["@owner"].Value = ConvertTo-DbNull $file.Owner
3194
3195 $cmd.Parameters.Add("@filenumber3", [System.Data.SqlDbType]::VarChar) | Out-Null
3196 $cmd.Parameters["@filenumber3"].Value = $file.FileNumber3
3197
3198 $cmd.Parameters.Add("@locked", [System.Data.SqlDbType]::Int) | Out-Null
3199 $cmd.Parameters["@locked"].Value = ConvertTo-DbNull $file.Locked
3200
3201 $cmd.Parameters.Add("@lockexpiration", [System.Data.SqlDbType]::DateTime) | Out-Null
3202 $cmd.Parameters["@lockexpiration"].Value = ConvertTo-DbNull $file.LockExpiration
3203
3204 $cmd.Parameters.Add("@locationid", [System.Data.SqlDbType]::Int) | Out-Null
3205 $cmd.Parameters["@locationid"].Value = $file.LocationId
3206
3207 $cmd.Parameters.Add("@lastmodified", [System.Data.SqlDbType]::DateTime) | Out-Null
3208 $cmd.Parameters["@lastmodified"].Value = ConvertTo-DbNull $file.LastModified
3209
3210 $cmd.Parameters.Add("@permissions", [System.Data.SqlDbType]::Image) | Out-Null
3211 if ($file.Permissions -ne $null) {$cmd.Parameters["@permissions"].Value = [byte[]]$file.Permissions}
3212 else {$cmd.Parameters["@permissions"].Value = (ConvertTo-DbNull $file.Permissions)}
3213
3214 $cmd.Parameters.Add("@created", [System.Data.SqlDbType]::DateTime) | Out-Null
3215 $cmd.Parameters["@created"].Value = $file.Created
3216
3217 $cmd.Parameters.Add("@datelastopened", [System.Data.SqlDbType]::DateTime) | Out-Null
3218 $cmd.Parameters["@datelastopened"].Value = ConvertTo-DbNull $file.DateLastOpened
3219
3220 $cmd.Parameters.Add("@isdeleted", [System.Data.SqlDbType]::Int) | Out-Null
3221 $cmd.Parameters["@isdeleted"].Value = $file.IsDeleted
3222
3223 $cmd.Parameters.Add("@istemporary", [System.Data.SqlDbType]::Int) | Out-Null
3224 $cmd.Parameters["@istemporary"].Value = $file.IsTemporary
3225
3226 $cmd.Parameters.Add("@isheld", [System.Data.SqlDbType]::Int) | Out-Null
3227 $cmd.Parameters["@isheld"].Value = ConvertTo-DbNull $file.IsHeld
3228
3229 $cmd.Parameters.Add("@isfrozen", [System.Data.SqlDbType]::Int) | Out-Null
3230 $cmd.Parameters["@isfrozen"].Value = ConvertTo-DbNull $file.IsFrozen
3231
3232 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3233 $cmd = (ConvertTo-OracleCommand $cmd)
3234
3235 if ($file.FileNumber -eq "") {$cmd.Parameters["@filenumber"].Value = " "}
3236 if ($file.FileNumber2 -eq "") {$cmd.Parameters["@filenumber2"].Value = " "}
3237 if ($file.FileNumber3 -eq "") {$cmd.Parameters["@filenumber3"].Value = " "}
3238 }
3239
3240 $cmd.Connection = $dbConn
3241
3242 $rowsAffected = $cmd.ExecuteNonQuery()
3243
3244 return $rowsAffected
3245 }
3246 catch {
3247 throw ("Error in Insert-File: " + $error[0])
3248 }
3249} # Insert-File
3250
3251
3252$global:diffQueries["FileMark_MasterNotAtSat"] = "
3253 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3254 select @satelliteid, 'FileMark', fm_mast.fileid, fm_mast.filemarkid, 'Unprocessed', @statustime
3255 from {MasterPrefix}FileMark{MasterSuffix} fm_mast
3256 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = fm_mast.fileid
3257 where f_mast.owner = @satelliteid
3258 and not exists (
3259 select 1
3260 from {SatellitePrefix}FileMark{SatelliteSuffix}
3261 where fileid = fm_mast.fileid
3262 and filemarkid = fm_mast.filemarkid
3263 )
3264"
3265
3266$global:diffQueries["FileMark_SatNotAtMaster"] = "
3267 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3268 select @satelliteid, 'FileMark', fm_sat.fileid, fm_sat.filemarkid, 'Unprocessed', @statustime
3269 from {SatellitePrefix}FileMark{SatelliteSuffix} fm_sat
3270 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = fm_sat.fileid
3271 where f_sat.owner = @satelliteid
3272 and not exists (
3273 select 1
3274 from {MasterPrefix}FileMark{MasterSuffix}
3275 where fileid = fm_sat.fileid
3276 and filemarkid = fm_sat.filemarkid
3277 )
3278"
3279
3280Function Merge-FileMark ($fileMark1, $fileMark2) {
3281 try {
3282 return $fileMark1
3283 }
3284 catch {
3285 throw ("Error in Merge-FileMark: " + $error[0])
3286 }
3287} # Merge-FileMark
3288
3289
3290# Create blank object once, so it can be copied to create new instances.
3291# This results in huge performance gains.
3292$global:blankFileMark = $global:blankItem.PSObject.Copy()
3293$global:blankFileMark.ItemType = "FileMark"
3294
3295
3296Function Select-FileMark ($fileId, $fileMarkId, $dbConn) {
3297 try {
3298 $cmd = New-Object System.Data.SqlClient.SqlCommand
3299
3300 $cmd.CommandText = "
3301 select f.owner
3302 from FileMark fm
3303 join Files f on f.fileid = fm.fileid
3304 where fm.fileid = @fileid
3305 and fm.filemarkid = @filemarkid
3306 "
3307
3308 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
3309 $cmd.Parameters["@fileid"].Value = $fileId
3310
3311 $cmd.Parameters.Add("@filemarkid", [System.Data.SqlDbType]::Int) | Out-Null
3312 $cmd.Parameters["@filemarkid"].Value = $fileMarkId
3313
3314 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3315 $cmd = (ConvertTo-OracleCommand $cmd)
3316 }
3317
3318 $cmd.Connection = $dbConn
3319
3320 $reader = $cmd.ExecuteReader()
3321
3322 if ($reader.Read()) {
3323 $fileMark = $global:blankFileMark.PSObject.Copy()
3324
3325 $fileMark.ItemId = $fileId
3326 $fileMark.ItemId2 = $fileMarkId
3327 $fileMark.Owner = ConvertTo-PsType $reader[0]
3328 }
3329 else {
3330 $fileMark = $null
3331 }
3332
3333 return $fileMark
3334 }
3335 catch {
3336 throw ("Error in Select-FileMark: " + $error[0])
3337 }
3338 finally {
3339 if ($reader) {$reader.Close()}
3340 }
3341} # Select-FileMark
3342
3343
3344Function Update-FileMark ($fileMark, $dbConn) {
3345 try {
3346 $cmd = New-Object System.Data.SqlClient.SqlCommand
3347
3348 $cmd.CommandText = "
3349 update FileMark
3350 set fileid = @fileid
3351 where fileid = @fileid and filemarkid = @filemarkid
3352 "
3353
3354 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
3355 $cmd.Parameters["@fileid"].Value = $fileMark.ItemId
3356
3357 $cmd.Parameters.Add("@filemarkid", [System.Data.SqlDbType]::Int) | Out-Null
3358 $cmd.Parameters["@filemarkid"].Value = $fileMark.ItemId2
3359
3360 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3361 $cmd = (ConvertTo-OracleCommand $cmd)
3362 }
3363
3364 $cmd.Connection = $dbConn
3365
3366 $rowsAffected = $cmd.ExecuteNonQuery()
3367
3368 return $rowsAffected
3369 }
3370 catch {
3371 throw ("Error in Update-FileMark: " + $error[0])
3372 }
3373} # Update-FileMark
3374
3375
3376Function Insert-FileMark ($fileMark, $dbConn) {
3377 try {
3378 $cmd = New-Object System.Data.SqlClient.SqlCommand
3379
3380 $cmd.CommandText = "
3381 insert into FileMark (fileid, filemarkid)
3382 values (@fileid, @filemarkid)
3383 "
3384
3385 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
3386 $cmd.Parameters["@fileid"].Value = $fileMark.ItemId
3387
3388 $cmd.Parameters.Add("@filemarkid", [System.Data.SqlDbType]::Int) | Out-Null
3389 $cmd.Parameters["@filemarkid"].Value = $fileMark.ItemId2
3390
3391 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3392 $cmd = (ConvertTo-OracleCommand $cmd)
3393 }
3394
3395 $cmd.Connection = $dbConn
3396
3397 $rowsAffected = $cmd.ExecuteNonQuery()
3398
3399 return $rowsAffected
3400 }
3401 catch {
3402 throw ("Error in Insert-FileMark: " + $error[0])
3403 }
3404} # Insert-FileMark
3405
3406
3407$global:diffQueries["FileRelation_MasterNotAtSat"] = "
3408 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3409 select @satelliteid, 'FileRelation', fr_mast.fromfileid, fr_mast.tofileid, 'Unprocessed', @statustime
3410 from {MasterPrefix}FileRelation{MasterSuffix} fr_mast
3411 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = fr_mast.fromfileid
3412 where f_mast.owner = @satelliteid
3413 and not exists (
3414 select 1
3415 from {SatellitePrefix}FileRelation{SatelliteSuffix}
3416 where fromfileid = fr_mast.fromfileid
3417 and tofileid = fr_mast.tofileid
3418 )
3419"
3420
3421$global:diffQueries["FileRelation_SatNotAtMaster"] = "
3422 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3423 select @satelliteid, 'FileRelation', fr_sat.fromfileid, fr_sat.tofileid, 'Unprocessed', @statustime
3424 from {SatellitePrefix}FileRelation{SatelliteSuffix} fr_sat
3425 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = fr_sat.fromfileid
3426 where f_sat.owner = @satelliteid
3427 and not exists (
3428 select 1
3429 from {MasterPrefix}FileRelation{MasterSuffix}
3430 where fromfileid = fr_sat.fromfileid
3431 and tofileid = fr_sat.tofileid
3432 )
3433"
3434
3435Function Merge-FileRelation ($fileRelation1, $fileRelation2) {
3436 try {
3437 return $fileRelation1
3438 }
3439 catch {
3440 throw ("Error in Merge-FileRelation: " + $error[0])
3441 }
3442} # Merge-FileRelation
3443
3444
3445# Create blank object once, so it can be copied to create new instances.
3446# This results in huge performance gains.
3447$global:blankFileRelation = $global:blankItem.PSObject.Copy()
3448$global:blankFileRelation.ItemType = "FileRelation"
3449
3450
3451Function Select-FileRelation ($fromFileId, $toFileId, $dbConn) {
3452 try {
3453 $cmd = New-Object System.Data.SqlClient.SqlCommand
3454
3455 $cmd.CommandText = "
3456 select f.owner
3457 from FileRelation fr
3458 join Files f on f.fileid = fr.fromfileid
3459 where fr.fromfileid = @fromfileid
3460 and fr.tofileid = @tofileid
3461 "
3462
3463 $cmd.Parameters.Add("@fromfileid", [System.Data.SqlDbType]::Int) | Out-Null
3464 $cmd.Parameters["@fromfileid"].Value = $fromFileId
3465
3466 $cmd.Parameters.Add("@tofileid", [System.Data.SqlDbType]::Int) | Out-Null
3467 $cmd.Parameters["@tofileid"].Value = $toFileId
3468
3469 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3470 $cmd = (ConvertTo-OracleCommand $cmd)
3471 }
3472
3473 $cmd.Connection = $dbConn
3474
3475 $reader = $cmd.ExecuteReader()
3476
3477 if ($reader.Read()) {
3478 $fileRelation = $global:blankFileRelation.PSObject.Copy()
3479
3480 $fileRelation.ItemId = $fromFileId
3481 $fileRelation.ItemId2 = $toFileId
3482 $fileRelation.Owner = ConvertTo-PsType $reader[0]
3483 }
3484 else {
3485 $fileRelation = $null
3486 }
3487
3488 return $fileRelation
3489 }
3490 catch {
3491 throw ("Error in Select-FileRelation: " + $error[0])
3492 }
3493 finally {
3494 if ($reader) {$reader.Close()}
3495 }
3496} # Select-FileRelation
3497
3498
3499Function Update-FileRelation ($fileRelation, $dbConn) {
3500 try {
3501 $cmd = New-Object System.Data.SqlClient.SqlCommand
3502
3503 $cmd.CommandText = "
3504 update FileRelation
3505 set tofileid = @tofileid
3506 where fromfileid = @fromfileid and tofileid = @tofileid
3507 "
3508
3509 $cmd.Parameters.Add("@fromfileid", [System.Data.SqlDbType]::Int) | Out-Null
3510 $cmd.Parameters["@fromfileid"].Value = $fileRelation.ItemId
3511
3512 $cmd.Parameters.Add("@tofileid", [System.Data.SqlDbType]::Int) | Out-Null
3513 $cmd.Parameters["@tofileid"].Value = $fileRelation.ItemId2
3514
3515 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3516 $cmd = (ConvertTo-OracleCommand $cmd)
3517 }
3518
3519 $cmd.Connection = $dbConn
3520
3521 $rowsAffected = $cmd.ExecuteNonQuery()
3522
3523 return $rowsAffected
3524 }
3525 catch {
3526 throw ("Error in Update-FileRelation: " + $error[0])
3527 }
3528} # Update-FileRelation
3529
3530
3531Function Insert-FileRelation ($fileRelation, $dbConn) {
3532 try {
3533 $cmd = New-Object System.Data.SqlClient.SqlCommand
3534
3535 $cmd.CommandText = "
3536 insert into FileRelation (fromfileid, tofileid)
3537 values (@fromfileid, @tofileid)
3538 "
3539
3540 $cmd.Parameters.Add("@fromfileid", [System.Data.SqlDbType]::Int) | Out-Null
3541 $cmd.Parameters["@fromfileid"].Value = $fileRelation.ItemId
3542
3543 $cmd.Parameters.Add("@tofileid", [System.Data.SqlDbType]::Int) | Out-Null
3544 $cmd.Parameters["@tofileid"].Value = $fileRelation.ItemId2
3545
3546 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3547 $cmd = (ConvertTo-OracleCommand $cmd)
3548 }
3549
3550 $cmd.Connection = $dbConn
3551
3552 $rowsAffected = $cmd.ExecuteNonQuery()
3553
3554 return $rowsAffected
3555 }
3556 catch {
3557 throw ("Error in Insert-FileRelation: " + $error[0])
3558 }
3559} # Insert-FileRelation
3560
3561
3562$global:diffQueries["FlowStack_MasterNotAtSat"] = "
3563 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3564 select @satelliteid, 'FlowStack', fs_mast.taskid, fs_mast.stacklevel, 'Unprocessed', @statustime
3565 from {MasterPrefix}FlowStack{MasterSuffix} fs_mast
3566 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = fs_mast.taskid
3567 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
3568 where f_mast.owner = @satelliteid
3569 and not exists (
3570 select 1
3571 from {SatellitePrefix}FlowStack{SatelliteSuffix}
3572 where taskid = fs_mast.taskid
3573 and stacklevel = fs_mast.stacklevel
3574 )
3575"
3576
3577$global:diffQueries["FlowStack_SatNotAtMaster"] = "
3578 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3579 select @satelliteid, 'FlowStack', fs_sat.taskid, fs_sat.stacklevel, 'Unprocessed', @statustime
3580 from {SatellitePrefix}FlowStack{SatelliteSuffix} fs_sat
3581 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = fs_sat.taskid
3582 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
3583 where not exists (
3584 select 1
3585 from {MasterPrefix}FlowStack{MasterSuffix}
3586 where taskid = fs_sat.taskid
3587 and stacklevel = fs_sat.stacklevel
3588 )
3589"
3590
3591$global:diffQueries["FlowStack_MasterSatDiff"] = "
3592 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3593 select @satelliteid, 'FlowStack', fs_mast.taskid, fs_mast.stacklevel, 'Unprocessed', @statustime
3594 from {MasterPrefix}FlowStack{MasterSuffix} fs_mast
3595 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = fs_mast.taskid
3596 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
3597 join {SatellitePrefix}FlowStack{SatelliteSuffix} fs_sat on fs_sat.taskid = fs_mast.taskid and fs_sat.stacklevel = fs_mast.stacklevel
3598 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = fs_sat.taskid
3599 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
3600 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
3601 and fs_mast.stepid <> fs_sat.stepid
3602"
3603
3604
3605Function Merge-FlowStack ($flowStack1, $flowStack2) {
3606 try {
3607 return $flowStack1
3608 }
3609 catch {
3610 throw ("Error in Merge-FlowStack: " + $error[0])
3611 }
3612} # Merge-FlowStack
3613
3614
3615# Create blank object once, so it can be copied to create new instances.
3616# This results in huge performance gains.
3617$global:blankFlowStack = $global:blankItem.PSObject.Copy()
3618$global:blankFlowStack.ItemType = "FlowStack"
3619$global:blankFlowStack | Add-Member NoteProperty StepId $null
3620
3621
3622Function Select-FlowStack ($taskId, $stackLevel, $dbConn) {
3623 try {
3624 $cmd = New-Object System.Data.SqlClient.SqlCommand
3625
3626 $cmd.CommandText = "
3627 select f.owner, fs.stepid
3628 from FlowStack fs
3629 join Task t on t.taskid = fs.taskid
3630 join Files f on f.fileid = t.fileid
3631 where fs.taskid = @taskid
3632 and fs.stacklevel = @stacklevel
3633 "
3634
3635 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
3636 $cmd.Parameters["@taskid"].Value = $taskId
3637
3638 $cmd.Parameters.Add("@stacklevel", [System.Data.SqlDbType]::Int) | Out-Null
3639 $cmd.Parameters["@stacklevel"].Value = $stackLevel
3640
3641 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3642 $cmd = (ConvertTo-OracleCommand $cmd)
3643 }
3644
3645 $cmd.Connection = $dbConn
3646
3647 $reader = $cmd.ExecuteReader()
3648
3649 if ($reader.Read()) {
3650 $flowStack = $global:blankFlowStack.PSObject.Copy()
3651
3652 $flowStack.ItemId = $taskId
3653 $flowStack.ItemId2 = $stackLevel
3654 $flowStack.Owner = ConvertTo-PsType $reader[0]
3655 $flowStack.StepId = ConvertTo-PsType $reader[1]
3656 }
3657 else {
3658 $flowStack = $null
3659 }
3660
3661 return $flowStack
3662 }
3663 catch {
3664 throw ("Error in Select-FlowStack: " + $error[0])
3665 }
3666 finally {
3667 if ($reader) {$reader.Close()}
3668 }
3669} # Select-FlowStack
3670
3671
3672Function Update-FlowStack ($flowStack, $dbConn) {
3673 try {
3674 $cmd = New-Object System.Data.SqlClient.SqlCommand
3675
3676 $cmd.CommandText = "
3677 update FlowStack
3678 set stepid = @stepid
3679 where taskid = @taskid
3680 and stacklevel = @stacklevel
3681 "
3682
3683 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
3684 $cmd.Parameters["@taskid"].Value = $flowStack.ItemId
3685
3686 $cmd.Parameters.Add("@stacklevel", [System.Data.SqlDbType]::Int) | Out-Null
3687 $cmd.Parameters["@stacklevel"].Value = $flowStack.ItemId2
3688
3689 $cmd.Parameters.Add("@stepid", [System.Data.SqlDbType]::Int) | Out-Null
3690 $cmd.Parameters["@stepid"].Value = $flowStack.StepId
3691
3692 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3693 $cmd = (ConvertTo-OracleCommand $cmd)
3694 }
3695
3696 $cmd.Connection = $dbConn
3697
3698 $rowsAffected = $cmd.ExecuteNonQuery()
3699
3700 return $rowsAffected
3701 }
3702 catch {
3703 throw ("Error in Update-FlowStack: " + $error[0])
3704 }
3705} # Update-FlowStack
3706
3707
3708Function Insert-FlowStack ($flowStack, $dbConn) {
3709 try {
3710 $cmd = New-Object System.Data.SqlClient.SqlCommand
3711
3712 $cmd.CommandText = "
3713 insert into FlowStack (taskid, stacklevel, stepid)
3714 values (@taskid, @stacklevel, @stepid)
3715 "
3716
3717 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
3718 $cmd.Parameters["@taskid"].Value = $flowStack.ItemId
3719
3720 $cmd.Parameters.Add("@stacklevel", [System.Data.SqlDbType]::Int) | Out-Null
3721 $cmd.Parameters["@stacklevel"].Value = $flowStack.ItemId2
3722
3723 $cmd.Parameters.Add("@stepid", [System.Data.SqlDbType]::Int) | Out-Null
3724 $cmd.Parameters["@stepid"].Value = $flowStack.StepId
3725
3726 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3727 $cmd = (ConvertTo-OracleCommand $cmd)
3728 }
3729
3730 $cmd.Connection = $dbConn
3731
3732 $rowsAffected = $cmd.ExecuteNonQuery()
3733
3734 return $rowsAffected
3735 }
3736 catch {
3737 throw ("Error in Insert-FlowStack: " + $error[0])
3738 }
3739} # Insert-FlowStack
3740
3741
3742Function Delete-FlowStack ($flowStack, $dbConn) {
3743 try {
3744 $cmd = New-Object System.Data.SqlClient.SqlCommand
3745
3746 $cmd.CommandText = "
3747 delete FlowStack where taskid = @taskid and stacklevel = @stacklevel
3748 "
3749
3750 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
3751 $cmd.Parameters["@taskid"].Value = $flowStack.ItemId
3752
3753 $cmd.Parameters.Add("@stacklevel", [System.Data.SqlDbType]::Int) | Out-Null
3754 $cmd.Parameters["@stacklevel"].Value = $flowStack.ItemId2
3755
3756 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3757 $cmd = (ConvertTo-OracleCommand $cmd)
3758 }
3759
3760 $cmd.Connection = $dbConn
3761
3762 $rowsAffected = $cmd.ExecuteNonQuery()
3763
3764 return $rowsAffected
3765 }
3766 catch {
3767 throw ("Error in Delete-FlowStack: " + $error[0])
3768 }
3769} # Delete-FlowStack
3770
3771
3772$global:diffQueries["Folder_MasterNotAtSat"] = "
3773 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3774 select @satelliteid, 'Folder', fldr_mast.docfolderid, null, 'Unprocessed', @statustime
3775 from {MasterPrefix}Folder{MasterSuffix} fldr_mast
3776 join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = fldr_mast.docfolderid
3777 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
3778 where f_mast.owner = @satelliteid
3779 and not exists (
3780 select 1
3781 from {SatellitePrefix}Folder{SatelliteSuffix}
3782 where docfolderid = fldr_mast.docfolderid
3783 )
3784"
3785
3786$global:diffQueries["Folder_SatNotAtMaster"] = "
3787 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3788 select @satelliteid, 'Folder', fldr_sat.docfolderid, null, 'Unprocessed', @statustime
3789 from {SatellitePrefix}Folder{SatelliteSuffix} fldr_sat
3790 where not exists (
3791 select 1
3792 from {MasterPrefix}Folder{MasterSuffix}
3793 where docfolderid = fldr_sat.docfolderid
3794 )
3795"
3796
3797$global:diffQueries["Folder_MasterSatDiff"] = "
3798 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3799 select @satelliteid, 'Folder', fldr_mast.docfolderid, null, 'Unprocessed', @statustime
3800 from {MasterPrefix}Folder{MasterSuffix} fldr_mast
3801 join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = fldr_mast.docfolderid
3802 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
3803 join {SatellitePrefix}Folder{SatelliteSuffix} fldr_sat on fldr_sat.docfolderid = fldr_mast.docfolderid
3804 join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = fldr_sat.docfolderid
3805 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = df_sat.fileid
3806 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
3807 and (
3808 fldr_mast.maxdocdate <> fldr_sat.maxdocdate
3809 or fldr_mast.maxdocdate is null and fldr_sat.maxdocdate is not null
3810 or fldr_mast.maxdocdate is not null and fldr_sat.maxdocdate is null
3811 or fldr_mast.maxcreated <> fldr_sat.maxcreated
3812 or fldr_mast.maxcreated is null and fldr_sat.maxcreated is not null
3813 or fldr_mast.maxcreated is not null and fldr_sat.maxcreated is null
3814 )
3815"
3816
3817
3818Function Merge-Folder ($folder1, $folder2) {
3819 try {
3820 $folder1.MaxDocDate = Merge-Value $folder1.MaxDocDate $folder2.MaxDocDate "ReplaceNull" "Greater"
3821 $folder1.MaxCreated = Merge-Value $folder1.MaxCreated $folder2.MaxCreated "ReplaceNull" "Greater"
3822
3823 return $folder1
3824 }
3825 catch {
3826 throw ("Error in Merge-Folder: " + $error[0])
3827 }
3828} # Merge-Folder
3829
3830
3831# Create blank object once, so it can be copied to create new instances.
3832# This results in huge performance gains.
3833$global:blankFolder = $global:blankItem.PSObject.Copy()
3834$global:blankFolder.ItemType = "Folder"
3835$global:blankFolder | Add-Member NoteProperty MaxDocDate $null
3836$global:blankFolder | Add-Member NoteProperty MaxCreated $null
3837
3838
3839Function Select-Folder ($docFolderId, $dbConn) {
3840 try {
3841 $cmd = New-Object System.Data.SqlClient.SqlCommand
3842
3843 $cmd.CommandText = "
3844 select f.owner, fldr.maxdocdate, fldr.maxcreated
3845 from Folder fldr
3846 join DocFolder df on df.docfolderid = fldr.docfolderid
3847 join Files f on f.fileid = df.fileid
3848 where fldr.docfolderid = @docfolderid
3849 "
3850
3851 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
3852 $cmd.Parameters["@docfolderid"].Value = $docFolderId
3853
3854 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3855 $cmd = (ConvertTo-OracleCommand $cmd)
3856 }
3857
3858 $cmd.Connection = $dbConn
3859
3860 $reader = $cmd.ExecuteReader()
3861
3862 if ($reader.Read()) {
3863 $folder = $global:blankFolder.PSObject.Copy()
3864
3865 $folder.ItemId = $docFolderId
3866 $folder.ItemId2 = $null
3867 $folder.Owner = ConvertTo-PsType $reader[0]
3868 $folder.MaxDocDate = ConvertTo-PsType $reader[1]
3869 $folder.MaxCreated = ConvertTo-PsType $reader[2]
3870 }
3871 else {
3872 $folder = $null
3873 }
3874
3875 return $folder
3876 }
3877 catch {
3878 throw ("Error in Select-Folder: " + $error[0])
3879 }
3880 finally {
3881 if ($reader) {$reader.Close()}
3882 }
3883} # Select-Folder
3884
3885
3886Function Update-Folder ($folder, $dbConn) {
3887 try {
3888 $cmd = New-Object System.Data.SqlClient.SqlCommand
3889
3890 $cmd.CommandText = "
3891 update Folder
3892 set maxdocdate = @maxdocdate, maxcreated = @maxcreated
3893 where docfolderid = @docfolderid
3894 "
3895
3896 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
3897 $cmd.Parameters["@docfolderid"].Value = $folder.ItemId
3898
3899 $cmd.Parameters.Add("@maxdocdate", [System.Data.SqlDbType]::DateTime) | Out-Null
3900 $cmd.Parameters["@maxdocdate"].Value = ConvertTo-DbNull $folder.MaxDocDate
3901
3902 $cmd.Parameters.Add("@maxcreated", [System.Data.SqlDbType]::DateTime) | Out-Null
3903 $cmd.Parameters["@maxcreated"].Value = ConvertTo-DbNull $folder.MaxCreated
3904
3905 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3906 $cmd = (ConvertTo-OracleCommand $cmd)
3907 }
3908
3909 $cmd.Connection = $dbConn
3910
3911 $rowsAffected = $cmd.ExecuteNonQuery()
3912
3913 return $rowsAffected
3914 }
3915 catch {
3916 throw ("Error in Update-Folder: " + $error[0])
3917 }
3918} # Update-Folder
3919
3920
3921Function Insert-Folder ($folder, $dbConn) {
3922 try {
3923 $cmd = New-Object System.Data.SqlClient.SqlCommand
3924
3925 $cmd.CommandText = "
3926 insert into Folder (docfolderid, maxdocdate, maxcreated)
3927 values (@docfolderid, @maxdocdate, @maxcreated)
3928 "
3929
3930 $cmd.Parameters.Add("@docfolderid", [System.Data.SqlDbType]::Int) | Out-Null
3931 $cmd.Parameters["@docfolderid"].Value = $folder.ItemId
3932
3933 $cmd.Parameters.Add("@maxdocdate", [System.Data.SqlDbType]::DateTime) | Out-Null
3934 $cmd.Parameters["@maxdocdate"].Value = ConvertTo-DbNull $folder.MaxDocDate
3935
3936 $cmd.Parameters.Add("@maxcreated", [System.Data.SqlDbType]::DateTime) | Out-Null
3937 $cmd.Parameters["@maxcreated"].Value = ConvertTo-DbNull $folder.MaxCreated
3938
3939 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
3940 $cmd = (ConvertTo-OracleCommand $cmd)
3941 }
3942
3943 $cmd.Connection = $dbConn
3944
3945 $rowsAffected = $cmd.ExecuteNonQuery()
3946
3947 return $rowsAffected
3948 }
3949 catch {
3950 throw ("Error in Insert-Folder: " + $error[0])
3951 }
3952} # Insert-Folder
3953
3954
3955$global:diffQueries["PageMark_MasterNotAtSat"] = "
3956 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3957 select @satelliteid, 'PageMark', pm_mast.pageid, pm_mast.pagemarkid, 'Unprocessed', @statustime
3958 from {MasterPrefix}PageMark{MasterSuffix} pm_mast
3959 join {MasterPrefix}Pages{MasterSuffix} p_mast on p_mast.pageid = pm_mast.pageid
3960 join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = p_mast.documentid
3961 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
3962 where f_mast.owner = @satelliteid
3963 and not exists (
3964 select 1
3965 from {SatellitePrefix}PageMark{SatelliteSuffix}
3966 where pageid = pm_mast.pageid
3967 and pagemarkid = pm_mast.pagemarkid
3968 )
3969"
3970
3971$global:diffQueries["PageMark_SatNotAtMaster"] = "
3972 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3973 select @satelliteid, 'PageMark', pm_sat.pageid, pm_sat.pagemarkid, 'Unprocessed', @statustime
3974 from {SatellitePrefix}PageMark{SatelliteSuffix} pm_sat
3975 join {SatellitePrefix}Pages{SatelliteSuffix} p_sat on p_sat.pageid = pm_sat.pageid
3976 join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = p_sat.documentid
3977 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = df_sat.fileid
3978 where f_sat.owner = @satelliteid
3979 and not exists (
3980 select 1
3981 from {MasterPrefix}PageMark{MasterSuffix}
3982 where pageid = pm_sat.pageid
3983 and pagemarkid = pm_sat.pagemarkid
3984 )
3985"
3986
3987$global:diffQueries["PageMark_MasterSatDiff"] = "
3988 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
3989 select @satelliteid, 'PageMark', pm_mast.pageid, pm_mast.pagemarkid, 'Unprocessed', @statustime
3990 from {MasterPrefix}PageMark{MasterSuffix} pm_mast
3991 join {MasterPrefix}Pages{MasterSuffix} p_mast on p_mast.pageid = pm_mast.pageid
3992 join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = p_mast.documentid
3993 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
3994 join {SatellitePrefix}PageMark{SatelliteSuffix} pm_sat on pm_sat.pageid = pm_mast.pageid and pm_sat.pagemarkid = pm_mast.pagemarkid
3995 join {SatellitePrefix}Pages{SatelliteSuffix} p_sat on p_sat.pageid = pm_sat.pageid
3996 join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = p_sat.documentid
3997 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = df_sat.fileid
3998 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
3999 and pm_mast.fileid <> pm_sat.fileid
4000"
4001
4002
4003Function Merge-PageMark ($pageMark1, $pageMark2) {
4004 try {
4005 return $pageMark1
4006 }
4007 catch {
4008 throw ("Error in Merge-PageMark: " + $error[0])
4009 }
4010} # Merge-PageMark
4011
4012
4013# Create blank object once, so it can be copied to create new instances.
4014# This results in huge performance gains.
4015$global:blankPageMark = $global:blankItem.PSObject.Copy()
4016$global:blankPageMark.ItemType = "PageMark"
4017$global:blankPageMark | Add-Member NoteProperty FileId $null
4018
4019
4020Function Select-PageMark ($pageId, $pageMarkId, $dbConn) {
4021 try {
4022 $cmd = New-Object System.Data.SqlClient.SqlCommand
4023
4024 $cmd.CommandText = "
4025 select f.owner, f.fileid
4026 from PageMark pm
4027 join Pages p on p.pageid = pm.pageid
4028 join DocFolder df on df.docfolderid = p.documentid
4029 join Files f on f.fileid = df.fileid
4030 where pm.pageid = @pageid
4031 and pm.pagemarkid = @pagemarkid
4032 "
4033
4034 $cmd.Parameters.Add("@pageid", [System.Data.SqlDbType]::Int) | Out-Null
4035 $cmd.Parameters["@pageid"].Value = $pageId
4036
4037 $cmd.Parameters.Add("@pagemarkid", [System.Data.SqlDbType]::Int) | Out-Null
4038 $cmd.Parameters["@pagemarkid"].Value = $pageMarkId
4039
4040 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4041 $cmd = (ConvertTo-OracleCommand $cmd)
4042 }
4043
4044 $cmd.Connection = $dbConn
4045
4046 $reader = $cmd.ExecuteReader()
4047
4048 if ($reader.Read()) {
4049 $pageMark = $global:blankPageMark.PSObject.Copy()
4050
4051 $pageMark.ItemId = $pageId
4052 $pageMark.ItemId2 = $pageMarkId
4053 $pageMark.Owner = ConvertTo-PsType $reader[0]
4054 $pageMark.FileId = ConvertTo-PsType $reader[1]
4055 }
4056 else {
4057 $pageMark = $null
4058 }
4059
4060 return $pageMark
4061 }
4062 catch {
4063 throw ("Error in Select-PageMark: " + $error[0])
4064 }
4065 finally {
4066 if ($reader) {$reader.Close()}
4067 }
4068} # Select-PageMark
4069
4070
4071Function Update-PageMark ($pageMark, $dbConn) {
4072 try {
4073 $cmd = New-Object System.Data.SqlClient.SqlCommand
4074
4075 $cmd.CommandText = "
4076 update PageMark
4077 set fileid = @fileid
4078 where pageid = @pageid
4079 and pagemarkid = @pagemarkid
4080 "
4081
4082 $cmd.Parameters.Add("@pageid", [System.Data.SqlDbType]::Int) | Out-Null
4083 $cmd.Parameters["@pageid"].Value = $pageMark.ItemId
4084
4085 $cmd.Parameters.Add("@pagemarkid", [System.Data.SqlDbType]::Int) | Out-Null
4086 $cmd.Parameters["@pagemarkid"].Value = $pageMark.ItemId2
4087
4088 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
4089 $cmd.Parameters["@fileid"].Value = $pageMark.FileId
4090
4091 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4092 $cmd = (ConvertTo-OracleCommand $cmd)
4093 }
4094
4095 $cmd.Connection = $dbConn
4096
4097 $rowsAffected = $cmd.ExecuteNonQuery()
4098
4099 return $rowsAffected
4100 }
4101 catch {
4102 throw ("Error in Update-PageMark: " + $error[0])
4103 }
4104} # Update-PageMark
4105
4106
4107Function Insert-PageMark ($pageMark, $dbConn) {
4108 try {
4109 $cmd = New-Object System.Data.SqlClient.SqlCommand
4110
4111 $cmd.CommandText = "
4112 insert into PageMark (pageid, pagemarkid, fileid)
4113 values (@pageid, @pagemarkid, @fileid)
4114 "
4115
4116 $cmd.Parameters.Add("@pageid", [System.Data.SqlDbType]::Int) | Out-Null
4117 $cmd.Parameters["@pageid"].Value = $pageMark.ItemId
4118
4119 $cmd.Parameters.Add("@pagemarkid", [System.Data.SqlDbType]::Int) | Out-Null
4120 $cmd.Parameters["@pagemarkid"].Value = $pageMark.ItemId2
4121
4122 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
4123 $cmd.Parameters["@fileid"].Value = $pageMark.FileId
4124
4125 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4126 $cmd = (ConvertTo-OracleCommand $cmd)
4127 }
4128
4129 $cmd.Connection = $dbConn
4130
4131 $rowsAffected = $cmd.ExecuteNonQuery()
4132
4133 return $rowsAffected
4134 }
4135 catch {
4136 throw ("Error in Insert-PageMark: " + $error[0])
4137 }
4138} # Insert-PageMark
4139
4140
4141$global:diffQueries["Page_MasterNotAtSat"] = "
4142 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4143 select @satelliteid, 'Page', p_mast.pageid, null, 'Unprocessed', @statustime
4144 from {MasterPrefix}Pages{MasterSuffix} p_mast
4145 join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = p_mast.documentid
4146 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
4147 where f_mast.owner = @satelliteid
4148 and not exists (
4149 select 1
4150 from {SatellitePrefix}Pages{SatelliteSuffix}
4151 where pageid = p_mast.pageid
4152 )
4153"
4154
4155$global:diffQueries["Page_SatNotAtMaster"] = "
4156 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4157 select @satelliteid, 'Page', p_sat.pageid, null, 'Unprocessed', @statustime
4158 from {SatellitePrefix}Pages{SatelliteSuffix} p_sat
4159 where not exists (
4160 select 1
4161 from {MasterPrefix}Pages{MasterSuffix}
4162 where pageid = p_sat.pageid
4163 )
4164"
4165
4166$global:diffQueries["Page_MasterSatDiff"] = "
4167 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4168 select @satelliteid, 'Page', p_mast.pageid, null, 'Unprocessed', @statustime
4169 from {MasterPrefix}Pages{MasterSuffix} p_mast
4170 join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = p_mast.documentid
4171 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = df_mast.fileid
4172 join {SatellitePrefix}Pages{SatelliteSuffix} p_sat on p_sat.pageid = p_mast.pageid
4173 join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = p_sat.documentid
4174 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = df_sat.fileid
4175 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
4176 and (
4177 p_mast.description <> p_sat.description
4178 or p_mast.pagenumber <> p_sat.pagenumber
4179 or p_mast.imagesetid <> p_sat.imagesetid
4180 or p_mast.lastmodified <> p_sat.lastmodified
4181 or p_mast.created <> p_sat.created
4182 or p_mast.documentid <> p_sat.documentid
4183 or p_mast.isdeleted <> p_sat.isdeleted
4184 )
4185"
4186
4187
4188Function Merge-Page ($page1, $page2) {
4189 try {
4190 $page1.LastModified = Merge-Value $page1.LastModified $page2.LastModified "ReplaceNull" "Greater"
4191 $page1.Created = Merge-Value $page1.Created $page2.Created "ReplaceNull" "Lesser"
4192
4193 return $page1
4194 }
4195 catch {
4196 throw ("Error in Merge-Page: " + $error[0])
4197 }
4198} # Merge-Page
4199
4200
4201# Create blank object once, so it can be copied to create new instances.
4202# This results in huge performance gains.
4203$global:blankPage = $global:blankItem.PSObject.Copy()
4204$global:blankPage.ItemType = "Page"
4205$global:blankPage | Add-Member NoteProperty Description $null
4206$global:blankPage | Add-Member NoteProperty PageNumber $null
4207$global:blankPage | Add-Member NoteProperty ImageSetId $null
4208$global:blankPage | Add-Member NoteProperty LastModified $null
4209$global:blankPage | Add-Member NoteProperty Created $null
4210$global:blankPage | Add-Member NoteProperty DocumentId $null
4211$global:blankPage | Add-Member NoteProperty IsDeleted $null
4212
4213
4214Function Select-Page ($pageId, $dbConn) {
4215 try {
4216 $cmd = New-Object System.Data.SqlClient.SqlCommand
4217
4218 $cmd.CommandText = "
4219 select f.owner, p.description, p.pagenumber, p.imagesetid, p.lastmodified, p.created,
4220 p.documentid, p.isdeleted
4221 from Pages p
4222 join DocFolder df on df.docfolderid = p.documentid
4223 join Files f on f.fileid = df.fileid
4224 where p.pageid = @pageid
4225 "
4226
4227 $cmd.Parameters.Add("@pageid", [System.Data.SqlDbType]::Int) | Out-Null
4228 $cmd.Parameters["@pageid"].Value = $pageId
4229
4230 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4231 $cmd = (ConvertTo-OracleCommand $cmd)
4232 }
4233
4234 $cmd.Connection = $dbConn
4235
4236 $reader = $cmd.ExecuteReader()
4237
4238 if ($reader.Read()) {
4239 $page = $global:blankPage.PSObject.Copy()
4240
4241 $page.ItemId = $pageId
4242 $page.ItemId2 = $null
4243 $page.Owner = ConvertTo-PsType $reader[0]
4244 $page.Description = ConvertTo-PsType $reader[1]
4245 $page.PageNumber = ConvertTo-PsType $reader[2]
4246 $page.ImageSetId = ConvertTo-PsType $reader[3]
4247 $page.LastModified = ConvertTo-PsType $reader[4]
4248 $page.Created = ConvertTo-PsType $reader[5]
4249 $page.DocumentId = ConvertTo-PsType $reader[6]
4250 $page.IsDeleted = ConvertTo-PsType $reader[7]
4251 }
4252 else {
4253 $page = $null
4254 }
4255
4256 return $page
4257 }
4258 catch {
4259 throw ("Error in Select-Page: " + $error[0])
4260 }
4261 finally {
4262 if ($reader) {$reader.Close()}
4263 }
4264} # Select-Page
4265
4266
4267Function Update-Page ($page, $dbConn) {
4268 try {
4269 $cmd = New-Object System.Data.SqlClient.SqlCommand
4270
4271 $cmd.CommandText = "
4272 update Pages
4273 set description = @description, pagenumber = @pagenumber, imagesetid = @imagesetid,
4274 lastmodified = @lastmodified, created = @created, documentid = @documentid, isdeleted = @isdeleted
4275 where pageid = @pageid
4276 "
4277
4278 $cmd.Parameters.Add("@pageid", [System.Data.SqlDbType]::Int) | Out-Null
4279 $cmd.Parameters["@pageid"].Value = $page.ItemId
4280
4281 $cmd.Parameters.Add("@description", [System.Data.SqlDbType]::VarChar) | Out-Null
4282 $cmd.Parameters["@description"].Value = $page.Description
4283
4284 $cmd.Parameters.Add("@pagenumber", [System.Data.SqlDbType]::Int) | Out-Null
4285 $cmd.Parameters["@pagenumber"].Value = $page.PageNumber
4286
4287 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
4288 $cmd.Parameters["@imagesetid"].Value = $page.ImageSetId
4289
4290 $cmd.Parameters.Add("@lastmodified", [System.Data.SqlDbType]::DateTime) | Out-Null
4291 $cmd.Parameters["@lastmodified"].Value = $page.LastModified
4292
4293 $cmd.Parameters.Add("@created", [System.Data.SqlDbType]::DateTime) | Out-Null
4294 $cmd.Parameters["@created"].Value = $page.Created
4295
4296 $cmd.Parameters.Add("@documentid", [System.Data.SqlDbType]::Int) | Out-Null
4297 $cmd.Parameters["@documentid"].Value = $page.DocumentId
4298
4299 $cmd.Parameters.Add("@isdeleted", [System.Data.SqlDbType]::Int) | Out-Null
4300 $cmd.Parameters["@isdeleted"].Value = $page.IsDeleted
4301
4302 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4303 $cmd = (ConvertTo-OracleCommand $cmd)
4304
4305 if ($page.Description -eq "") {$cmd.Parameters["@description"].Value = " "}
4306 }
4307
4308 $cmd.Connection = $dbConn
4309
4310 $rowsAffected = $cmd.ExecuteNonQuery()
4311
4312 return $rowsAffected
4313 }
4314 catch {
4315 throw ("Error in Update-Page: " + $error[0])
4316 }
4317} # Update-Page
4318
4319
4320Function Insert-Page ($page, $dbConn) {
4321 try {
4322 $cmd = New-Object System.Data.SqlClient.SqlCommand
4323
4324 $cmd.CommandText = "
4325 insert into Pages (pageid, description, pagenumber, imagesetid, lastmodified, created, documentid, isdeleted)
4326 values (@pageid, @description, @pagenumber, @imagesetid, @lastmodified, @created, @documentid, @isdeleted)
4327 "
4328
4329 $cmd.Parameters.Add("@pageid", [System.Data.SqlDbType]::Int) | Out-Null
4330 $cmd.Parameters["@pageid"].Value = $page.ItemId
4331
4332 $cmd.Parameters.Add("@description", [System.Data.SqlDbType]::VarChar) | Out-Null
4333 $cmd.Parameters["@description"].Value = $page.Description
4334
4335 $cmd.Parameters.Add("@pagenumber", [System.Data.SqlDbType]::Int) | Out-Null
4336 $cmd.Parameters["@pagenumber"].Value = $page.PageNumber
4337
4338 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
4339 $cmd.Parameters["@imagesetid"].Value = $page.ImageSetId
4340
4341 $cmd.Parameters.Add("@lastmodified", [System.Data.SqlDbType]::DateTime) | Out-Null
4342 $cmd.Parameters["@lastmodified"].Value = $page.LastModified
4343
4344 $cmd.Parameters.Add("@created", [System.Data.SqlDbType]::DateTime) | Out-Null
4345 $cmd.Parameters["@created"].Value = $page.Created
4346
4347 $cmd.Parameters.Add("@documentid", [System.Data.SqlDbType]::Int) | Out-Null
4348 $cmd.Parameters["@documentid"].Value = $page.DocumentId
4349
4350 $cmd.Parameters.Add("@isdeleted", [System.Data.SqlDbType]::Int) | Out-Null
4351 $cmd.Parameters["@isdeleted"].Value = $page.IsDeleted
4352
4353 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4354 $cmd = (ConvertTo-OracleCommand $cmd)
4355
4356 if ($page.Description -eq "") {$cmd.Parameters["@description"].Value = " "}
4357 }
4358
4359 $cmd.Connection = $dbConn
4360
4361 $rowsAffected = $cmd.ExecuteNonQuery()
4362
4363 return $rowsAffected
4364 }
4365 catch {
4366 throw ("Error in Insert-Page: " + $error[0])
4367 }
4368} # Insert-Page
4369
4370
4371$global:diffQueries["SubTask_MasterNotAtSat"] = "
4372 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4373 select @satelliteid, 'SubTask', st_mast.supertaskid, st_mast.subtaskid, 'Unprocessed', @statustime
4374 from {MasterPrefix}SubTask{MasterSuffix} st_mast
4375 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = st_mast.supertaskid
4376 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
4377 where f_mast.owner = @satelliteid
4378 and not exists (
4379 select 1
4380 from {SatellitePrefix}SubTask{SatelliteSuffix}
4381 where supertaskid = st_mast.supertaskid
4382 and subtaskid = st_mast.subtaskid
4383 )
4384"
4385
4386$global:diffQueries["SubTask_SatNotAtMaster"] = "
4387 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4388 select @satelliteid, 'SubTask', st_sat.supertaskid, st_sat.subtaskid, 'Unprocessed', @statustime
4389 from {SatellitePrefix}SubTask{SatelliteSuffix} st_sat
4390 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = st_sat.supertaskid
4391 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
4392 where f_sat.owner = @satelliteid
4393 and not exists (
4394 select 1
4395 from {MasterPrefix}SubTask{MasterSuffix}
4396 where supertaskid = st_sat.supertaskid
4397 and subtaskid = st_sat.subtaskid
4398 )
4399"
4400
4401$global:diffQueries["SubTask_MasterSatDiff"] = "
4402 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4403 select @satelliteid, 'SubTask', st_mast.supertaskid, st_mast.subtaskid, 'Unprocessed', @statustime
4404 from {MasterPrefix}SubTask{MasterSuffix} st_mast
4405 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = st_mast.supertaskid
4406 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
4407 join {SatellitePrefix}SubTask{SatelliteSuffix} st_sat on st_sat.supertaskid = st_mast.supertaskid and st_sat.subtaskid = st_mast.subtaskid
4408 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = st_sat.supertaskid
4409 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
4410 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
4411 and (
4412 st_mast.rendezvousstepid <> st_sat.rendezvousstepid
4413 or st_mast.isrequired <> st_sat.isrequired
4414 )
4415"
4416
4417
4418Function Merge-SubTask ($subTask1, $subTask2) {
4419 try {
4420 return $subTask1
4421 }
4422 catch {
4423 throw ("Error in Merge-SubTask: " + $error[0])
4424 }
4425} # Merge-SubTask
4426
4427
4428# Create blank object once, so it can be copied to create new instances.
4429# This results in huge performance gains.
4430$global:blankSubTask = $global:blankItem.PSObject.Copy()
4431$global:blankSubTask.ItemType = "SubTask"
4432$global:blankSubTask | Add-Member NoteProperty RendezvousStepId $null
4433$global:blankSubTask | Add-Member NoteProperty IsRequired $null
4434
4435
4436Function Select-SubTask ($superTaskId, $subTaskId, $dbConn) {
4437 try {
4438 $cmd = New-Object System.Data.SqlClient.SqlCommand
4439
4440 $cmd.CommandText = "
4441 select f.owner, st.rendezvousstepid, st.isrequired
4442 from SubTask st
4443 join Task t on t.taskid = st.supertaskid
4444 join Files f on f.fileid = t.fileid
4445 where st.supertaskid = @supertaskid
4446 and st.subtaskid = @subtaskid
4447 "
4448
4449 $cmd.Parameters.Add("@supertaskid", [System.Data.SqlDbType]::Int) | Out-Null
4450 $cmd.Parameters["@supertaskid"].Value = $superTaskId
4451
4452 $cmd.Parameters.Add("@subtaskid", [System.Data.SqlDbType]::Int) | Out-Null
4453 $cmd.Parameters["@subtaskid"].Value = $subTaskId
4454
4455 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4456 $cmd = (ConvertTo-OracleCommand $cmd)
4457 }
4458
4459 $cmd.Connection = $dbConn
4460
4461 $reader = $cmd.ExecuteReader()
4462
4463 if ($reader.Read()) {
4464 $subTask = $global:blankSubTask.PSObject.Copy()
4465
4466 $subTask.ItemId = $superTaskId
4467 $subTask.ItemId2 = $subTaskId
4468 $subTask.Owner = ConvertTo-PsType $reader[0]
4469 $subTask.RendezvousStepId = ConvertTo-PsType $reader[1]
4470 $subTask.IsRequired = ConvertTo-PsType $reader[2]
4471 }
4472 else {
4473 $subTask = $null
4474 }
4475
4476 return $subTask
4477 }
4478 catch {
4479 throw ("Error in Select-SubTask: " + $error[0])
4480 }
4481 finally {
4482 if ($reader) {$reader.Close()}
4483 }
4484} # Select-SubTask
4485
4486
4487Function Update-SubTask ($subTask, $dbConn) {
4488 try {
4489 $cmd = New-Object System.Data.SqlClient.SqlCommand
4490
4491 $cmd.CommandText = "
4492 update SubTask
4493 set rendezvousstepid = @rendezvousstepid, isrequired = @isrequired
4494 where supertaskid = @supertaskid
4495 and subtaskid = @subtaskid
4496 "
4497
4498 $cmd.Parameters.Add("@supertaskid", [System.Data.SqlDbType]::Int) | Out-Null
4499 $cmd.Parameters["@supertaskid"].Value = $subTask.ItemId
4500
4501 $cmd.Parameters.Add("@subtaskid", [System.Data.SqlDbType]::Int) | Out-Null
4502 $cmd.Parameters["@subtaskid"].Value = $subTask.ItemId2
4503
4504 $cmd.Parameters.Add("@rendezvousstepid", [System.Data.SqlDbType]::Int) | Out-Null
4505 $cmd.Parameters["@rendezvousstepid"].Value = $subTask.RendezvousStepId
4506
4507 $cmd.Parameters.Add("@isrequired", [System.Data.SqlDbType]::Int) | Out-Null
4508 $cmd.Parameters["@isrequired"].Value = $subTask.IsRequired
4509
4510 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4511 $cmd = (ConvertTo-OracleCommand $cmd)
4512 }
4513
4514 $cmd.Connection = $dbConn
4515
4516 $rowsAffected = $cmd.ExecuteNonQuery()
4517
4518 return $rowsAffected
4519 }
4520 catch {
4521 throw ("Error in Update-SubTask: " + $error[0])
4522 }
4523} # Update-SubTask
4524
4525
4526Function Insert-SubTask ($subTask, $dbConn) {
4527 try {
4528 $cmd = New-Object System.Data.SqlClient.SqlCommand
4529
4530 $cmd.CommandText = "
4531 insert into SubTask (supertaskid, subtaskid, rendezvousstepid, isrequired)
4532 values (@supertaskid, @subtaskid, @rendezvousstepid, @isrequired)
4533 "
4534
4535 $cmd.Parameters.Add("@supertaskid", [System.Data.SqlDbType]::Int) | Out-Null
4536 $cmd.Parameters["@supertaskid"].Value = $subTask.ItemId
4537
4538 $cmd.Parameters.Add("@subtaskid", [System.Data.SqlDbType]::Int) | Out-Null
4539 $cmd.Parameters["@subtaskid"].Value = $subTask.ItemId2
4540
4541 $cmd.Parameters.Add("@rendezvousstepid", [System.Data.SqlDbType]::Int) | Out-Null
4542 $cmd.Parameters["@rendezvousstepid"].Value = $subTask.RendezvousStepId
4543
4544 $cmd.Parameters.Add("@isrequired", [System.Data.SqlDbType]::Int) | Out-Null
4545 $cmd.Parameters["@isrequired"].Value = $subTask.IsRequired
4546
4547 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4548 $cmd = (ConvertTo-OracleCommand $cmd)
4549 }
4550
4551 $cmd.Connection = $dbConn
4552
4553 $rowsAffected = $cmd.ExecuteNonQuery()
4554
4555 return $rowsAffected
4556 }
4557 catch {
4558 throw ("Error in Insert-SubTask: " + $error[0])
4559 }
4560} # Insert-SubTask
4561
4562
4563Function Delete-SubTask ($subTask, $dbConn) {
4564 try {
4565 $cmd = New-Object System.Data.SqlClient.SqlCommand
4566
4567 $cmd.CommandText = "
4568 delete SubTask where supertaskid = @supertaskid and subtaskid = @subtaskid
4569 "
4570
4571 $cmd.Parameters.Add("@supertaskid", [System.Data.SqlDbType]::Int) | Out-Null
4572 $cmd.Parameters["@supertaskid"].Value = $subTask.ItemId
4573
4574 $cmd.Parameters.Add("@subtaskid", [System.Data.SqlDbType]::Int) | Out-Null
4575 $cmd.Parameters["@subtaskid"].Value = $subTask.ItemId2
4576
4577 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4578 $cmd = (ConvertTo-OracleCommand $cmd)
4579 }
4580
4581 $cmd.Connection = $dbConn
4582
4583 $rowsAffected = $cmd.ExecuteNonQuery()
4584
4585 return $rowsAffected
4586 }
4587 catch {
4588 throw ("Error in Delete-SubTask: " + $error[0])
4589 }
4590} # Delete-SubTask
4591
4592
4593$global:diffQueries["Task_MasterNotAtSat"] = "
4594 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4595 select @satelliteid, 'Task', t_mast.taskid, null, 'Unprocessed', @statustime
4596 from {MasterPrefix}Task{MasterSuffix} t_mast
4597 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
4598 where f_mast.owner = @satelliteid
4599 and not exists (
4600 select 1
4601 from {SatellitePrefix}Task{SatelliteSuffix}
4602 where taskid = t_mast.taskid
4603 )
4604"
4605
4606$global:diffQueries["Task_SatNotAtMaster"] = "
4607 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4608 select @satelliteid, 'Task', t_sat.taskid, null, 'Unprocessed', @statustime
4609 from {SatellitePrefix}Task{SatelliteSuffix} t_sat
4610 where not exists (
4611 select 1
4612 from {MasterPrefix}Task{MasterSuffix}
4613 where taskid = t_sat.taskid
4614 )
4615"
4616
4617$global:diffQueries["Task_MasterSatDiff"] = "
4618 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
4619 select @satelliteid, 'Task', t_mast.taskid, null, 'Unprocessed', @statustime
4620 from {MasterPrefix}Task{MasterSuffix} t_mast
4621 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
4622 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = t_mast.taskid
4623 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
4624 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
4625 and (
4626 t_mast.fileid <> t_sat.fileid
4627 or t_mast.stepid <> t_sat.stepid
4628 or t_mast.assignedto <> t_sat.assignedto
4629 or t_mast.assignedto is null and t_sat.assignedto is not null
4630 or t_mast.assignedto is not null and t_sat.assignedto is null
4631 or t_mast.objectid <> t_sat.objectid
4632 or t_mast.pagenumber <> t_sat.pagenumber
4633 or t_mast.pagenumber is null and t_sat.pagenumber is not null
4634 or t_mast.pagenumber is not null and t_sat.pagenumber is null
4635 or t_mast.priority <> t_sat.priority
4636 or t_mast.debug <> t_sat.debug
4637 or t_mast.status <> t_sat.status
4638 or t_mast.description <> t_sat.description
4639 or t_mast.description is null and t_sat.description is not null
4640 or t_mast.description is not null and t_sat.description is null
4641 or cast(t_mast.taskdata as varbinary(max)) <> cast(t_sat.taskdata as varbinary(max))
4642 or t_mast.taskdata is null and t_sat.taskdata is not null
4643 or t_mast.taskdata is not null and t_sat.taskdata is null
4644 or t_mast.undoexpires <> t_sat.undoexpires
4645 or t_mast.undoexpires is null and t_sat.undoexpires is not null
4646 or t_mast.undoexpires is not null and t_sat.undoexpires is null
4647 or t_mast.starttime <> t_sat.starttime
4648 or t_mast.dateavailable <> t_sat.dateavailable
4649 or t_mast.deadline <> t_sat.deadline
4650 or t_mast.deadline is null and t_sat.deadline is not null
4651 or t_mast.deadline is not null and t_sat.deadline is null
4652 or t_mast.stacklevel <> t_sat.stacklevel
4653 or t_mast.stacklevel is null and t_sat.stacklevel is not null
4654 or t_mast.stacklevel is not null and t_sat.stacklevel is null
4655 or t_mast.sender <> t_sat.sender
4656 or t_mast.sender is null and t_sat.sender is not null
4657 or t_mast.sender is not null and t_sat.sender is null
4658 or t_mast.senderstep <> t_sat.senderstep
4659 or t_mast.senderstep is null and t_sat.senderstep is not null
4660 or t_mast.senderstep is not null and t_sat.senderstep is null
4661 or t_mast.errornum <> t_sat.errornum
4662 or t_mast.errornum is null and t_sat.errornum is not null
4663 or t_mast.errornum is not null and t_sat.errornum is null
4664 or t_mast.errordesc <> t_sat.errordesc
4665 or t_mast.errordesc is null and t_sat.errordesc is not null
4666 or t_mast.errordesc is not null and t_sat.errordesc is null
4667 or t_mast.noteid <> t_sat.noteid
4668 or t_mast.noteid is null and t_sat.noteid is not null
4669 or t_mast.noteid is not null and t_sat.noteid is null
4670 or t_mast.statusdetails <> t_sat.statusdetails
4671 or t_mast.statusdetails is null and t_sat.statusdetails is not null
4672 or t_mast.statusdetails is not null and t_sat.statusdetails is null
4673 )
4674"
4675
4676
4677Function Merge-Task ($task1, $task2) {
4678 try {
4679 if ($task1.Owner -ne $task1.SiteId) {
4680 $task1.DateEnded = Merge-Value $task1.DateEnded $task2.DateEnded "ReplaceNull"
4681 }
4682
4683 return $task1
4684 }
4685 catch {
4686 throw ("Error in Merge-Task: " + $error[0])
4687 }
4688} # Merge-Task
4689
4690
4691# Create blank object once, so it can be copied to create new instances.
4692# This results in huge performance gains.
4693$global:blankTask = $global:blankItem.PSObject.Copy()
4694$global:blankTask.ItemType = "Task"
4695$global:blankTask | Add-Member NoteProperty FileId $null
4696$global:blankTask | Add-Member NoteProperty StepId $null
4697$global:blankTask | Add-Member NoteProperty AssignedTo $null
4698$global:blankTask | Add-Member NoteProperty ObjectId $null
4699$global:blankTask | Add-Member NoteProperty PageNumber $null
4700$global:blankTask | Add-Member NoteProperty LockExpiration $null
4701$global:blankTask | Add-Member NoteProperty LockBy $null
4702$global:blankTask | Add-Member NoteProperty Priority $null
4703$global:blankTask | Add-Member NoteProperty Debug $null
4704$global:blankTask | Add-Member NoteProperty Status $null
4705$global:blankTask | Add-Member NoteProperty Description $null
4706$global:blankTask | Add-Member NoteProperty TaskData $null
4707$global:blankTask | Add-Member NoteProperty UndoExpires $null
4708$global:blankTask | Add-Member NoteProperty StartTime $null
4709$global:blankTask | Add-Member NoteProperty DateAvailable $null
4710$global:blankTask | Add-Member NoteProperty Deadline $null
4711$global:blankTask | Add-Member NoteProperty StackLevel $null
4712$global:blankTask | Add-Member NoteProperty Sender $null
4713$global:blankTask | Add-Member NoteProperty SenderStep $null
4714$global:blankTask | Add-Member NoteProperty ErrorNum $null
4715$global:blankTask | Add-Member NoteProperty ErrorDesc $null
4716$global:blankTask | Add-Member NoteProperty NoteId $null
4717$global:blankTask | Add-Member NoteProperty StatusDetails $null
4718
4719
4720Function Select-Task ($taskId, $dbConn) {
4721 try {
4722 $cmd = New-Object System.Data.SqlClient.SqlCommand
4723
4724 $cmd.CommandText = "
4725 select f.owner, t.fileid, t.stepid, t.assignedto, t.objectid, t.pagenumber, t.lockexpiration, t.lockby,
4726 t.priority, t.debug, t.status, t.description, t.taskdata, t.undoexpires, t.starttime, t.dateavailable,
4727 t.deadline, t.stacklevel, t.sender, t.senderstep, t.errornum, t.errordesc, t.noteid, t.statusdetails
4728 from Task t
4729 join Files f on f.fileid = t.fileid
4730 where t.taskid = @taskid
4731 "
4732
4733 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
4734 $cmd.Parameters["@taskid"].Value = $taskId
4735
4736 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4737 $cmd = (ConvertTo-OracleCommand $cmd)
4738 }
4739
4740 $cmd.Connection = $dbConn
4741
4742 $reader = $cmd.ExecuteReader()
4743
4744 if ($reader.Read()) {
4745 $task = $global:blankTask.PSObject.Copy()
4746
4747 $task.ItemId = $taskId
4748 $task.ItemId2 = $null
4749 $task.Owner = ConvertTo-PsType $reader[0]
4750 $task.FileId = ConvertTo-PsType $reader[1]
4751 $task.StepId = ConvertTo-PsType $reader[2]
4752 $task.AssignedTo = ConvertTo-PsType $reader[3]
4753 $task.ObjectId = ConvertTo-PsType $reader[4]
4754 $task.PageNumber = ConvertTo-PsType $reader[5]
4755 $task.LockExpiration = ConvertTo-PsType $reader[6]
4756 $task.LockBy = ConvertTo-PsType $reader[7]
4757 $task.Priority = ConvertTo-PsType $reader[8]
4758 $task.Debug = ConvertTo-PsType $reader[9]
4759 $task.Status = ConvertTo-PsType $reader[10]
4760 $task.Description = ConvertTo-PsType $reader[11]
4761 $task.TaskData = ConvertTo-PsType $reader[12]
4762 $task.UndoExpires = ConvertTo-PsType $reader[13]
4763 $task.StartTime = ConvertTo-PsType $reader[14]
4764 $task.DateAvailable = ConvertTo-PsType $reader[15]
4765 $task.Deadline = ConvertTo-PsType $reader[16]
4766 $task.StackLevel = ConvertTo-PsType $reader[17]
4767 $task.Sender = ConvertTo-PsType $reader[18]
4768 $task.SenderStep = ConvertTo-PsType $reader[19]
4769 $task.ErrorNum = ConvertTo-PsType $reader[20]
4770 $task.ErrorDesc = ConvertTo-PsType $reader[21]
4771 $task.NoteId = ConvertTo-PsType $reader[22]
4772 $task.StatusDetails = ConvertTo-PsType $reader[23]
4773 }
4774 else {
4775 $task = $null
4776 }
4777
4778 return $task
4779 }
4780 catch {
4781 throw ("Error in Select-Task: " + $error[0])
4782 }
4783 finally {
4784 if ($reader) {$reader.Close()}
4785 }
4786} # Select-Task
4787
4788
4789Function Update-Task ($task, $dbConn) {
4790 try {
4791 $cmd = New-Object System.Data.SqlClient.SqlCommand
4792
4793 $cmd.CommandText = "
4794 update Task
4795 set fileid = @fileid, stepid = @stepid, assignedto = @assignedto, objectid = @objectid,
4796 pagenumber = @pagenumber, lockexpiration = @lockexpiration, lockby = @lockby,
4797 priority = @priority, debug = @debug, status = @status, description = @description,
4798 taskdata = @taskdata, undoexpires = @undoexpires, starttime = @starttime,
4799 dateavailable = @dateavailable, deadline = @deadline, stacklevel = @stacklevel,
4800 sender = @sender, senderstep = @senderstep, errornum = @errornum, errordesc = @errordesc,
4801 noteid = @noteid, statusdetails = @statusdetails
4802 where taskid = @taskid
4803 "
4804
4805 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
4806 $cmd.Parameters["@taskid"].Value = $task.ItemId
4807
4808 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
4809 $cmd.Parameters["@fileid"].Value = $task.FileId
4810
4811 $cmd.Parameters.Add("@stepid", [System.Data.SqlDbType]::Int) | Out-Null
4812 $cmd.Parameters["@stepid"].Value = $task.StepId
4813
4814 $cmd.Parameters.Add("@assignedto", [System.Data.SqlDbType]::Int) | Out-Null
4815 $cmd.Parameters["@assignedto"].Value = ConvertTo-DbNull $task.AssignedTo
4816
4817 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
4818 $cmd.Parameters["@objectid"].Value = $task.ObjectId
4819
4820 $cmd.Parameters.Add("@pagenumber", [System.Data.SqlDbType]::Int) | Out-Null
4821 $cmd.Parameters["@pagenumber"].Value = ConvertTo-DbNull $task.PageNumber
4822
4823 $cmd.Parameters.Add("@lockexpiration", [System.Data.SqlDbType]::DateTime) | Out-Null
4824 $cmd.Parameters["@lockexpiration"].Value = ConvertTo-DbNull $task.LockExpiration
4825
4826 $cmd.Parameters.Add("@lockby", [System.Data.SqlDbType]::Int) | Out-Null
4827 $cmd.Parameters["@lockby"].Value = ConvertTo-DbNull $task.LockBy
4828
4829 $cmd.Parameters.Add("@priority", [System.Data.SqlDbType]::Int) | Out-Null
4830 $cmd.Parameters["@priority"].Value = $task.Priority
4831
4832 $cmd.Parameters.Add("@debug", [System.Data.SqlDbType]::Int) | Out-Null
4833 $cmd.Parameters["@debug"].Value = $task.Debug
4834
4835 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::Int) | Out-Null
4836 $cmd.Parameters["@status"].Value = $task.Status
4837
4838 $cmd.Parameters.Add("@description", [System.Data.SqlDbType]::VarChar) | Out-Null
4839 $cmd.Parameters["@description"].Value = ConvertTo-DbNull $task.Description
4840
4841 $cmd.Parameters.Add("@taskdata", [System.Data.SqlDbType]::Image) | Out-Null
4842 if ($task.TaskData -ne $null) {$cmd.Parameters["@taskdata"].Value = [byte[]]$task.TaskData}
4843 else {$cmd.Parameters["@taskdata"].Value = (ConvertTo-DbNull $task.TaskData)}
4844
4845 $cmd.Parameters.Add("@undoexpires", [System.Data.SqlDbType]::DateTime) | Out-Null
4846 $cmd.Parameters["@undoexpires"].Value = ConvertTo-DbNull $task.UndoExpires
4847
4848 $cmd.Parameters.Add("@starttime", [System.Data.SqlDbType]::DateTime) | Out-Null
4849 $cmd.Parameters["@starttime"].Value = $task.StartTime
4850
4851 $cmd.Parameters.Add("@dateavailable", [System.Data.SqlDbType]::DateTime) | Out-Null
4852 $cmd.Parameters["@dateavailable"].Value = $task.DateAvailable
4853
4854 $cmd.Parameters.Add("@deadline", [System.Data.SqlDbType]::DateTime) | Out-Null
4855 $cmd.Parameters["@deadline"].Value = ConvertTo-DbNull $task.Deadline
4856
4857 $cmd.Parameters.Add("@stacklevel", [System.Data.SqlDbType]::Int) | Out-Null
4858 $cmd.Parameters["@stacklevel"].Value = ConvertTo-DbNull $task.StackLevel
4859
4860 $cmd.Parameters.Add("@sender", [System.Data.SqlDbType]::Int) | Out-Null
4861 $cmd.Parameters["@sender"].Value = ConvertTo-DbNull $task.Sender
4862
4863 $cmd.Parameters.Add("@senderstep", [System.Data.SqlDbType]::Int) | Out-Null
4864 $cmd.Parameters["@senderstep"].Value = ConvertTo-DbNull $task.SenderStep
4865
4866 $cmd.Parameters.Add("@errornum", [System.Data.SqlDbType]::Int) | Out-Null
4867 $cmd.Parameters["@errornum"].Value = ConvertTo-DbNull $task.ErrorNum
4868
4869 $cmd.Parameters.Add("@errordesc", [System.Data.SqlDbType]::VarChar) | Out-Null
4870 $cmd.Parameters["@errordesc"].Value = ConvertTo-DbNull $task.ErrorDesc
4871
4872 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
4873 $cmd.Parameters["@noteid"].Value = ConvertTo-DbNull $task.NoteId
4874
4875 $cmd.Parameters.Add("@statusdetails", [System.Data.SqlDbType]::Int) | Out-Null
4876 $cmd.Parameters["@statusdetails"].Value = ConvertTo-DbNull $task.StatusDetails
4877
4878 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4879 $cmd = (ConvertTo-OracleCommand $cmd)
4880 }
4881
4882 $cmd.Connection = $dbConn
4883
4884 $rowsAffected = $cmd.ExecuteNonQuery()
4885
4886 return $rowsAffected
4887 }
4888 catch {
4889 throw ("Error in Update-Task: " + $error[0])
4890 }
4891} # Update-Task
4892
4893
4894Function Insert-Task ($task, $dbConn) {
4895 try {
4896 $cmd = New-Object System.Data.SqlClient.SqlCommand
4897
4898 $cmd.CommandText = "
4899 insert into Task (
4900 taskid, fileid, stepid, assignedto, objectid, pagenumber, lockexpiration, lockby,
4901 priority, debug, status, description, taskdata, undoexpires, starttime,
4902 dateavailable, deadline, stacklevel, sender, senderstep, errornum, errordesc,
4903 noteid, statusdetails
4904 )
4905 values (
4906 @taskid, @fileid, @stepid, @assignedto, @objectid, @pagenumber, @lockexpiration, @lockby,
4907 @priority, @debug, @status, @description, @taskdata, @undoexpires, @starttime,
4908 @dateavailable, @deadline, @stacklevel, @sender, @senderstep, @errornum, @errordesc,
4909 @noteid, @statusdetails
4910 )
4911 "
4912
4913 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
4914 $cmd.Parameters["@taskid"].Value = $task.ItemId
4915
4916 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
4917 $cmd.Parameters["@fileid"].Value = $task.FileId
4918
4919 $cmd.Parameters.Add("@stepid", [System.Data.SqlDbType]::Int) | Out-Null
4920 $cmd.Parameters["@stepid"].Value = $task.StepId
4921
4922 $cmd.Parameters.Add("@assignedto", [System.Data.SqlDbType]::Int) | Out-Null
4923 $cmd.Parameters["@assignedto"].Value = ConvertTo-DbNull $task.AssignedTo
4924
4925 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
4926 $cmd.Parameters["@objectid"].Value = $task.ObjectId
4927
4928 $cmd.Parameters.Add("@pagenumber", [System.Data.SqlDbType]::Int) | Out-Null
4929 $cmd.Parameters["@pagenumber"].Value = ConvertTo-DbNull $task.PageNumber
4930
4931 $cmd.Parameters.Add("@lockexpiration", [System.Data.SqlDbType]::DateTime) | Out-Null
4932 $cmd.Parameters["@lockexpiration"].Value = ConvertTo-DbNull $task.LockExpiration
4933
4934 $cmd.Parameters.Add("@lockby", [System.Data.SqlDbType]::Int) | Out-Null
4935 $cmd.Parameters["@lockby"].Value = ConvertTo-DbNull $task.LockBy
4936
4937 $cmd.Parameters.Add("@priority", [System.Data.SqlDbType]::Int) | Out-Null
4938 $cmd.Parameters["@priority"].Value = $task.Priority
4939
4940 $cmd.Parameters.Add("@debug", [System.Data.SqlDbType]::Int) | Out-Null
4941 $cmd.Parameters["@debug"].Value = $task.Debug
4942
4943 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::Int) | Out-Null
4944 $cmd.Parameters["@status"].Value = $task.Status
4945
4946 $cmd.Parameters.Add("@description", [System.Data.SqlDbType]::VarChar) | Out-Null
4947 $cmd.Parameters["@description"].Value = ConvertTo-DbNull $task.Description
4948
4949 $cmd.Parameters.Add("@taskdata", [System.Data.SqlDbType]::Image) | Out-Null
4950 if ($task.TaskData -ne $null) {$cmd.Parameters["@taskdata"].Value = [byte[]]$task.TaskData}
4951 else {$cmd.Parameters["@taskdata"].Value = (ConvertTo-DbNull $task.TaskData)}
4952
4953 $cmd.Parameters.Add("@undoexpires", [System.Data.SqlDbType]::DateTime) | Out-Null
4954 $cmd.Parameters["@undoexpires"].Value = ConvertTo-DbNull $task.UndoExpires
4955
4956 $cmd.Parameters.Add("@starttime", [System.Data.SqlDbType]::DateTime) | Out-Null
4957 $cmd.Parameters["@starttime"].Value = $task.StartTime
4958
4959 $cmd.Parameters.Add("@dateavailable", [System.Data.SqlDbType]::DateTime) | Out-Null
4960 $cmd.Parameters["@dateavailable"].Value = $task.DateAvailable
4961
4962 $cmd.Parameters.Add("@deadline", [System.Data.SqlDbType]::DateTime) | Out-Null
4963 $cmd.Parameters["@deadline"].Value = ConvertTo-DbNull $task.Deadline
4964
4965 $cmd.Parameters.Add("@stacklevel", [System.Data.SqlDbType]::Int) | Out-Null
4966 $cmd.Parameters["@stacklevel"].Value = ConvertTo-DbNull $task.StackLevel
4967
4968 $cmd.Parameters.Add("@sender", [System.Data.SqlDbType]::Int) | Out-Null
4969 $cmd.Parameters["@sender"].Value = ConvertTo-DbNull $task.Sender
4970
4971 $cmd.Parameters.Add("@senderstep", [System.Data.SqlDbType]::Int) | Out-Null
4972 $cmd.Parameters["@senderstep"].Value = ConvertTo-DbNull $task.SenderStep
4973
4974 $cmd.Parameters.Add("@errornum", [System.Data.SqlDbType]::Int) | Out-Null
4975 $cmd.Parameters["@errornum"].Value = ConvertTo-DbNull $task.ErrorNum
4976
4977 $cmd.Parameters.Add("@errordesc", [System.Data.SqlDbType]::VarChar) | Out-Null
4978 $cmd.Parameters["@errordesc"].Value = ConvertTo-DbNull $task.ErrorDesc
4979
4980 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
4981 $cmd.Parameters["@noteid"].Value = ConvertTo-DbNull $task.NoteId
4982
4983 $cmd.Parameters.Add("@statusdetails", [System.Data.SqlDbType]::Int) | Out-Null
4984 $cmd.Parameters["@statusdetails"].Value = ConvertTo-DbNull $task.StatusDetails
4985
4986 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
4987 $cmd = (ConvertTo-OracleCommand $cmd)
4988 }
4989
4990 $cmd.Connection = $dbConn
4991
4992 $rowsAffected = $cmd.ExecuteNonQuery()
4993
4994 return $rowsAffected
4995 }
4996 catch {
4997 throw ("Error in Insert-Task: " + $error[0])
4998 }
4999} # Insert-Task
5000
5001
5002Function Delete-Task ($taskId, $dbConn) {
5003 try {
5004 $cmd = New-Object System.Data.SqlClient.SqlCommand
5005
5006 $cmd.CommandText = "
5007 delete from Task where taskid = @taskid
5008 "
5009
5010 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5011 $cmd.Parameters["@taskid"].Value = $taskId
5012
5013 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5014 $cmd = (ConvertTo-OracleCommand $cmd)
5015 }
5016
5017 $cmd.Connection = $dbConn
5018
5019 $cmd.ExecuteNonQuery() | Out-Null
5020 }
5021 catch {
5022 throw ("Error in Delete-Task: " + $error[0])
5023 }
5024} # Delete-Task
5025
5026
5027Function Delete-TaskAttrBinaryByTaskId ($taskId, $dbConn) {
5028 try {
5029 $cmd = New-Object System.Data.SqlClient.SqlCommand
5030
5031 $cmd.CommandText = "
5032 delete from TaskAttrBinary where taskid = @taskid
5033 "
5034
5035 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5036 $cmd.Parameters["@taskid"].Value = $taskId
5037
5038 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5039 $cmd = (ConvertTo-OracleCommand $cmd)
5040 }
5041
5042 $cmd.Connection = $dbConn
5043
5044 $cmd.ExecuteNonQuery() | Out-Null
5045 }
5046 catch {
5047 throw ("Error in Delete-TaskAttrBinaryByTaskId: " + $error[0])
5048 }
5049} # Delete-TaskAttrBinaryByTaskId
5050
5051
5052Function Delete-TaskAttrCharByTaskId ($taskId, $dbConn) {
5053 try {
5054 $cmd = New-Object System.Data.SqlClient.SqlCommand
5055
5056 $cmd.CommandText = "
5057 delete from TaskAttrChar where taskid = @taskid
5058 "
5059
5060 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5061 $cmd.Parameters["@taskid"].Value = $taskId
5062
5063 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5064 $cmd = (ConvertTo-OracleCommand $cmd)
5065 }
5066
5067 $cmd.Connection = $dbConn
5068
5069 $cmd.ExecuteNonQuery() | Out-Null
5070 }
5071 catch {
5072 throw ("Error in Delete-TaskAttrCharByTaskId: " + $error[0])
5073 }
5074} # Delete-TaskAttrCharByTaskId
5075
5076
5077Function Delete-TaskAttrDateByTaskId ($taskId, $dbConn) {
5078 try {
5079 $cmd = New-Object System.Data.SqlClient.SqlCommand
5080
5081 $cmd.CommandText = "
5082 delete from TaskAttrDate where taskid = @taskid
5083 "
5084
5085 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5086 $cmd.Parameters["@taskid"].Value = $taskId
5087
5088 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5089 $cmd = (ConvertTo-OracleCommand $cmd)
5090 }
5091
5092 $cmd.Connection = $dbConn
5093
5094 $cmd.ExecuteNonQuery() | Out-Null
5095 }
5096 catch {
5097 throw ("Error in Delete-TaskAttrDateByTaskId: " + $error[0])
5098 }
5099} # Delete-TaskAttrDateByTaskId
5100
5101
5102Function Delete-TaskAttrFloatByTaskId ($taskId, $dbConn) {
5103 try {
5104 $cmd = New-Object System.Data.SqlClient.SqlCommand
5105
5106 $cmd.CommandText = "
5107 delete from TaskAttrFloat where taskid = @taskid
5108 "
5109
5110 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5111 $cmd.Parameters["@taskid"].Value = $taskId
5112
5113 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5114 $cmd = (ConvertTo-OracleCommand $cmd)
5115 }
5116
5117 $cmd.Connection = $dbConn
5118
5119 $cmd.ExecuteNonQuery() | Out-Null
5120 }
5121 catch {
5122 throw ("Error in Delete-TaskAttrFloatByTaskId: " + $error[0])
5123 }
5124} # Delete-TaskAttrFloatByTaskId
5125
5126
5127Function Delete-TaskAttrIntByTaskId ($taskId, $dbConn) {
5128 try {
5129 $cmd = New-Object System.Data.SqlClient.SqlCommand
5130
5131 $cmd.CommandText = "
5132 delete from TaskAttrInt where taskid = @taskid
5133 "
5134
5135 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5136 $cmd.Parameters["@taskid"].Value = $taskId
5137
5138 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5139 $cmd = (ConvertTo-OracleCommand $cmd)
5140 }
5141
5142 $cmd.Connection = $dbConn
5143
5144 $cmd.ExecuteNonQuery() | Out-Null
5145 }
5146 catch {
5147 throw ("Error in Delete-TaskAttrIntByTaskId: " + $error[0])
5148 }
5149} # Delete-TaskAttrIntByTaskId
5150
5151
5152Function Delete-FlowStackByTaskId ($taskId, $dbConn) {
5153 try {
5154 $cmd = New-Object System.Data.SqlClient.SqlCommand
5155
5156 $cmd.CommandText = "
5157 delete from FlowStack where taskid = @taskid
5158 "
5159
5160 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5161 $cmd.Parameters["@taskid"].Value = $taskId
5162
5163 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5164 $cmd = (ConvertTo-OracleCommand $cmd)
5165 }
5166
5167 $cmd.Connection = $dbConn
5168
5169 $cmd.ExecuteNonQuery() | Out-Null
5170 }
5171 catch {
5172 throw ("Error in Delete-FlowStackByTaskId: " + $error[0])
5173 }
5174} # Delete-FlowStackByTaskId
5175
5176
5177Function Delete-SubTaskByTaskId ($taskId, $dbConn) {
5178 try {
5179 $cmd = New-Object System.Data.SqlClient.SqlCommand
5180
5181 $cmd.CommandText = "
5182 delete from SubTask where supertaskid = @taskid or subtaskid = @taskid
5183 "
5184
5185 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5186 $cmd.Parameters["@taskid"].Value = $taskId
5187
5188 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5189 $cmd = (ConvertTo-OracleCommand $cmd)
5190 }
5191
5192 $cmd.Connection = $dbConn
5193
5194 $cmd.ExecuteNonQuery() | Out-Null
5195 }
5196 catch {
5197 throw ("Error in Delete-SubTaskByTaskId: " + $error[0])
5198 }
5199} # Delete-SubTaskByTaskId
5200
5201
5202$global:diffQueries["TaskAttrBinary_MasterNotAtSat"] = "
5203 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5204 select @satelliteid, 'TaskAttrBinary', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
5205 from {MasterPrefix}TaskAttrBinary{MasterSuffix} attr_mast
5206 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
5207 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
5208 where f_mast.owner = @satelliteid
5209 and not exists (
5210 select 1
5211 from {SatellitePrefix}TaskAttrBinary{SatelliteSuffix}
5212 where taskid = attr_mast.taskid
5213 and attributeid = attr_mast.attributeid
5214 )
5215"
5216
5217$global:diffQueries["TaskAttrBinary_SatNotAtMaster"] = "
5218 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5219 select @satelliteid, 'TaskAttrBinary', attr_sat.taskid, attr_sat.attributeid, 'Unprocessed', @statustime
5220 from {SatellitePrefix}TaskAttrBinary{SatelliteSuffix} attr_sat
5221 where not exists (
5222 select 1
5223 from {MasterPrefix}TaskAttrBinary{MasterSuffix}
5224 where taskid = attr_sat.taskid
5225 and attributeid = attr_sat.attributeid
5226 )
5227"
5228
5229$global:diffQueries["TaskAttrBinary_MasterSatDiff"] = "
5230 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5231 select @satelliteid, 'TaskAttrBinary', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
5232 from {MasterPrefix}TaskAttrBinary{MasterSuffix} attr_mast
5233 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
5234 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
5235 join {SatellitePrefix}TaskAttrBinary{SatelliteSuffix} attr_sat on attr_sat.taskid = attr_mast.taskid and attr_sat.attributeid = attr_mast.attributeid
5236 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = attr_sat.taskid
5237 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
5238 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
5239 and (
5240 cast(attr_mast.binvalue as varbinary(max)) <> cast(attr_sat.binvalue as varbinary(max))
5241 or attr_mast.binvalue is null and attr_sat.binvalue is not null
5242 or attr_mast.binvalue is not null and attr_sat.binvalue is null
5243 )
5244"
5245
5246
5247Function Merge-TaskAttrBinary ($attr1, $attr2) {
5248 try {
5249 return $attr1
5250 }
5251 catch {
5252 throw ("Error in Merge-TaskAttrBinary: " + $error[0])
5253 }
5254} # Merge-TaskAttrBinary
5255
5256
5257# Create blank object once, so it can be copied to create new instances.
5258# This results in huge performance gains.
5259$global:blankTaskAttrBinary = $global:blankItem.PSObject.Copy()
5260$global:blankTaskAttrBinary.ItemType = "TaskAttrBinary"
5261$global:blankTaskAttrBinary | Add-Member NoteProperty Value $null
5262
5263Function Select-TaskAttrBinary ($taskId, $attributeId, $dbConn) {
5264 try {
5265 $cmd = New-Object System.Data.SqlClient.SqlCommand
5266
5267 $cmd.CommandText = "
5268 select f.owner, a.binvalue
5269 from TaskAttrBinary a
5270 join Task t on t.taskid = a.taskid
5271 join Files f on f.fileid = t.fileid
5272 where a.taskid = @taskid
5273 and a.attributeid = @attributeid
5274 "
5275
5276 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5277 $cmd.Parameters["@taskid"].Value = $taskId
5278
5279 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5280 $cmd.Parameters["@attributeid"].Value = $attributeId
5281
5282 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5283 $cmd = (ConvertTo-OracleCommand $cmd)
5284 }
5285
5286 $cmd.Connection = $dbConn
5287
5288 $reader = $cmd.ExecuteReader()
5289
5290 if ($reader.Read()) {
5291 $attr = $global:blankTaskAttrBinary.PSObject.Copy()
5292
5293 $attr.ItemId = $taskId
5294 $attr.ItemId2 = $attributeId
5295 $attr.Owner = ConvertTo-PsType $reader[0]
5296 $attr.Value = ConvertTo-PsType $reader[1]
5297 }
5298 else {
5299 $attr = $null
5300 }
5301
5302 return $attr
5303 }
5304 catch {
5305 throw ("Error in Select-TaskAttrBinary: " + $error[0])
5306 }
5307 finally {
5308 if ($reader) {$reader.Close()}
5309 }
5310} # Select-TaskAttrBinary
5311
5312
5313Function Update-TaskAttrBinary ($attr, $dbConn) {
5314 try {
5315 $cmd = New-Object System.Data.SqlClient.SqlCommand
5316
5317 $cmd.CommandText = "
5318 update TaskAttrBinary
5319 set binvalue = @value
5320 where taskid = @taskid
5321 and attributeid = @attributeid
5322 "
5323
5324 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5325 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5326
5327 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5328 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5329
5330 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Image) | Out-Null
5331 if ($attr.Value -ne $null) {$cmd.Parameters["@value"].Value = [byte[]]$attr.Value}
5332 else {$cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)}
5333
5334 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5335 $cmd = (ConvertTo-OracleCommand $cmd)
5336 }
5337
5338 $cmd.Connection = $dbConn
5339
5340 $rowsAffected = $cmd.ExecuteNonQuery()
5341
5342 return $rowsAffected
5343 }
5344 catch {
5345 throw ("Error in Update-TaskAttrBinary: " + $error[0])
5346 }
5347} # Update-TaskAttrBinary
5348
5349
5350Function Insert-TaskAttrBinary ($attr, $dbConn) {
5351 try {
5352 $cmd = New-Object System.Data.SqlClient.SqlCommand
5353
5354 $cmd.CommandText = "
5355 insert into TaskAttrBinary (taskid, attributeid, binvalue)
5356 values (@taskid, @attributeid, @value)
5357 "
5358
5359 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5360 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5361
5362 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5363 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5364
5365 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Image) | Out-Null
5366 if ($attr.Value -ne $null) {$cmd.Parameters["@value"].Value = [byte[]]$attr.Value}
5367 else {$cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)}
5368
5369 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5370 $cmd = (ConvertTo-OracleCommand $cmd)
5371 }
5372
5373 $cmd.Connection = $dbConn
5374
5375 $rowsAffected = $cmd.ExecuteNonQuery()
5376
5377 return $rowsAffected
5378 }
5379 catch {
5380 throw ("Error in Insert-TaskAttrBinary: " + $error[0])
5381 }
5382} # Insert-TaskAttrBinary
5383
5384
5385Function Delete-TaskAttrBinary ($attr, $dbConn) {
5386 try {
5387 $cmd = New-Object System.Data.SqlClient.SqlCommand
5388
5389 $cmd.CommandText = "
5390 delete TaskAttrBinary where taskid = @taskid and attributeid = @attributeid
5391 "
5392
5393 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5394 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5395
5396 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5397 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5398
5399 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5400 $cmd = (ConvertTo-OracleCommand $cmd)
5401 }
5402
5403 $cmd.Connection = $dbConn
5404
5405 $rowsAffected = $cmd.ExecuteNonQuery()
5406
5407 return $rowsAffected
5408 }
5409 catch {
5410 throw ("Error in Delete-TaskAttrBinary: " + $error[0])
5411 }
5412} # Delete-TaskAttrBinary
5413
5414
5415$global:diffQueries["TaskAttrChar_MasterNotAtSat"] = "
5416 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5417 select @satelliteid, 'TaskAttrChar', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
5418 from {MasterPrefix}TaskAttrChar{MasterSuffix} attr_mast
5419 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
5420 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
5421 where f_mast.owner = @satelliteid
5422 and not exists (
5423 select 1
5424 from {SatellitePrefix}TaskAttrChar{SatelliteSuffix}
5425 where taskid = attr_mast.taskid
5426 and attributeid = attr_mast.attributeid
5427 )
5428"
5429
5430$global:diffQueries["TaskAttrChar_SatNotAtMaster"] = "
5431 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5432 select @satelliteid, 'TaskAttrChar', attr_sat.taskid, attr_sat.attributeid, 'Unprocessed', @statustime
5433 from {SatellitePrefix}TaskAttrChar{SatelliteSuffix} attr_sat
5434 where not exists (
5435 select 1
5436 from {MasterPrefix}TaskAttrChar{MasterSuffix}
5437 where taskid = attr_sat.taskid
5438 and attributeid = attr_sat.attributeid
5439 )
5440"
5441
5442$global:diffQueries["TaskAttrChar_MasterSatDiff"] = "
5443 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5444 select @satelliteid, 'TaskAttrChar', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
5445 from {MasterPrefix}TaskAttrChar{MasterSuffix} attr_mast
5446 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
5447 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
5448 join {SatellitePrefix}TaskAttrChar{SatelliteSuffix} attr_sat on attr_sat.taskid = attr_mast.taskid and attr_sat.attributeid = attr_mast.attributeid
5449 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = attr_sat.taskid
5450 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
5451 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
5452 and (
5453 attr_mast.charvalue <> attr_sat.charvalue
5454 or attr_mast.charvalue is null and attr_sat.charvalue is not null
5455 or attr_mast.charvalue is not null and attr_sat.charvalue is null
5456 )
5457"
5458
5459
5460Function Merge-TaskAttrChar ($attr1, $attr2) {
5461 try {
5462 return $attr1
5463 }
5464 catch {
5465 throw ("Error in Merge-TaskAttrChar: " + $error[0])
5466 }
5467} # Merge-TaskAttrChar
5468
5469
5470# Create blank object once, so it can be copied to create new instances.
5471# This results in huge performance gains.
5472$global:blankTaskAttrChar = $global:blankItem.PSObject.Copy()
5473$global:blankTaskAttrChar.ItemType = "TaskAttrChar"
5474$global:blankTaskAttrChar | Add-Member NoteProperty Value $null
5475
5476Function Select-TaskAttrChar ($taskId, $attributeId, $dbConn) {
5477 try {
5478 $cmd = New-Object System.Data.SqlClient.SqlCommand
5479
5480 $cmd.CommandText = "
5481 select f.owner, a.charvalue
5482 from TaskAttrChar a
5483 join Task t on t.taskid = a.taskid
5484 join Files f on f.fileid = t.fileid
5485 where a.taskid = @taskid
5486 and a.attributeid = @attributeid
5487 "
5488
5489 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5490 $cmd.Parameters["@taskid"].Value = $taskId
5491
5492 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5493 $cmd.Parameters["@attributeid"].Value = $attributeId
5494
5495 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5496 $cmd = (ConvertTo-OracleCommand $cmd)
5497 }
5498
5499 $cmd.Connection = $dbConn
5500
5501 $reader = $cmd.ExecuteReader()
5502
5503 if ($reader.Read()) {
5504 $attr = $global:blankTaskAttrChar.PSObject.Copy()
5505
5506 $attr.ItemId = $taskId
5507 $attr.ItemId2 = $attributeId
5508 $attr.Owner = ConvertTo-PsType $reader[0]
5509 $attr.Value = ConvertTo-PsType $reader[1]
5510 }
5511 else {
5512 $attr = $null
5513 }
5514
5515 return $attr
5516 }
5517 catch {
5518 throw ("Error in Select-TaskAttrChar: " + $error[0])
5519 }
5520 finally {
5521 if ($reader) {$reader.Close()}
5522 }
5523} # Select-TaskAttrChar
5524
5525
5526Function Update-TaskAttrChar ($attr, $dbConn) {
5527 try {
5528 $cmd = New-Object System.Data.SqlClient.SqlCommand
5529
5530 $cmd.CommandText = "
5531 update TaskAttrChar
5532 set charvalue = @value
5533 where taskid = @taskid
5534 and attributeid = @attributeid
5535 "
5536
5537 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5538 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5539
5540 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5541 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5542
5543 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::VarChar) | Out-Null
5544 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
5545
5546 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5547 $cmd = (ConvertTo-OracleCommand $cmd)
5548 }
5549
5550 $cmd.Connection = $dbConn
5551
5552 $rowsAffected = $cmd.ExecuteNonQuery()
5553
5554 return $rowsAffected
5555 }
5556 catch {
5557 throw ("Error in Update-TaskAttrChar: " + $error[0])
5558 }
5559} # Update-TaskAttrChar
5560
5561
5562Function Insert-TaskAttrChar ($attr, $dbConn) {
5563 try {
5564 $cmd = New-Object System.Data.SqlClient.SqlCommand
5565
5566 $cmd.CommandText = "
5567 insert into TaskAttrChar (taskid, attributeid, charvalue)
5568 values (@taskid, @attributeid, @value)
5569 "
5570
5571 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5572 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5573
5574 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5575 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5576
5577 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::VarChar) | Out-Null
5578 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
5579
5580 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5581 $cmd = (ConvertTo-OracleCommand $cmd)
5582 }
5583
5584 $cmd.Connection = $dbConn
5585
5586 $rowsAffected = $cmd.ExecuteNonQuery()
5587
5588 return $rowsAffected
5589 }
5590 catch {
5591 throw ("Error in Insert-TaskAttrChar: " + $error[0])
5592 }
5593} # Insert-TaskAttrChar
5594
5595
5596Function Delete-TaskAttrChar ($attr, $dbConn) {
5597 try {
5598 $cmd = New-Object System.Data.SqlClient.SqlCommand
5599
5600 $cmd.CommandText = "
5601 delete TaskAttrChar where taskid = @taskid and attributeid = @attributeid
5602 "
5603
5604 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5605 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5606
5607 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5608 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5609
5610 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5611 $cmd = (ConvertTo-OracleCommand $cmd)
5612 }
5613
5614 $cmd.Connection = $dbConn
5615
5616 $rowsAffected = $cmd.ExecuteNonQuery()
5617
5618 return $rowsAffected
5619 }
5620 catch {
5621 throw ("Error in Delete-TaskAttrChar: " + $error[0])
5622 }
5623} # Delete-TaskAttrChar
5624
5625
5626$global:diffQueries["TaskAttrDate_MasterNotAtSat"] = "
5627 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5628 select @satelliteid, 'TaskAttrDate', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
5629 from {MasterPrefix}TaskAttrDate{MasterSuffix} attr_mast
5630 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
5631 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
5632 where f_mast.owner = @satelliteid
5633 and not exists (
5634 select 1
5635 from {SatellitePrefix}TaskAttrDate{SatelliteSuffix}
5636 where taskid = attr_mast.taskid
5637 and attributeid = attr_mast.attributeid
5638 )
5639"
5640
5641$global:diffQueries["TaskAttrDate_SatNotAtMaster"] = "
5642 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5643 select @satelliteid, 'TaskAttrDate', attr_sat.taskid, attr_sat.attributeid, 'Unprocessed', @statustime
5644 from {SatellitePrefix}TaskAttrDate{SatelliteSuffix} attr_sat
5645 where not exists (
5646 select 1
5647 from {MasterPrefix}TaskAttrDate{MasterSuffix}
5648 where taskid = attr_sat.taskid
5649 and attributeid = attr_sat.attributeid
5650 )
5651"
5652
5653$global:diffQueries["TaskAttrDate_MasterSatDiff"] = "
5654 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5655 select @satelliteid, 'TaskAttrDate', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
5656 from {MasterPrefix}TaskAttrDate{MasterSuffix} attr_mast
5657 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
5658 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
5659 join {SatellitePrefix}TaskAttrDate{SatelliteSuffix} attr_sat on attr_sat.taskid = attr_mast.taskid and attr_sat.attributeid = attr_mast.attributeid
5660 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = attr_sat.taskid
5661 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
5662 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
5663 and (
5664 attr_mast.datevalue <> attr_sat.datevalue
5665 or attr_mast.datevalue is null and attr_sat.datevalue is not null
5666 or attr_mast.datevalue is not null and attr_sat.datevalue is null
5667 )
5668"
5669
5670
5671Function Merge-TaskAttrDate ($attr1, $attr2) {
5672 try {
5673 return $attr1
5674 }
5675 catch {
5676 throw ("Error in Merge-TaskAttrDate: " + $error[0])
5677 }
5678} # Merge-TaskAttrDate
5679
5680
5681# Create blank object once, so it can be copied to create new instances.
5682# This results in huge performance gains.
5683$global:blankTaskAttrDate = $global:blankItem.PSObject.Copy()
5684$global:blankTaskAttrDate.ItemType = "TaskAttrDate"
5685$global:blankTaskAttrDate | Add-Member NoteProperty Value $null
5686
5687Function Select-TaskAttrDate ($taskId, $attributeId, $dbConn) {
5688 try {
5689 $cmd = New-Object System.Data.SqlClient.SqlCommand
5690
5691 $cmd.CommandText = "
5692 select f.owner, a.datevalue
5693 from TaskAttrDate a
5694 join Task t on t.taskid = a.taskid
5695 join Files f on f.fileid = t.fileid
5696 where a.taskid = @taskid
5697 and a.attributeid = @attributeid
5698 "
5699
5700 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5701 $cmd.Parameters["@taskid"].Value = $taskId
5702
5703 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5704 $cmd.Parameters["@attributeid"].Value = $attributeId
5705
5706 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5707 $cmd = (ConvertTo-OracleCommand $cmd)
5708 }
5709
5710 $cmd.Connection = $dbConn
5711
5712 $reader = $cmd.ExecuteReader()
5713
5714 if ($reader.Read()) {
5715 $attr = $global:blankTaskAttrDate.PSObject.Copy()
5716
5717 $attr.ItemId = $taskId
5718 $attr.ItemId2 = $attributeId
5719 $attr.Owner = ConvertTo-PsType $reader[0]
5720 $attr.Value = ConvertTo-PsType $reader[1]
5721 }
5722 else {
5723 $attr = $null
5724 }
5725
5726 return $attr
5727 }
5728 catch {
5729 throw ("Error in Select-TaskAttrDate: " + $error[0])
5730 }
5731 finally {
5732 if ($reader) {$reader.Close()}
5733 }
5734} # Select-TaskAttrDate
5735
5736
5737Function Update-TaskAttrDate ($attr, $dbConn) {
5738 try {
5739 $cmd = New-Object System.Data.SqlClient.SqlCommand
5740
5741 $cmd.CommandText = "
5742 update TaskAttrDate
5743 set datevalue = @value
5744 where taskid = @taskid
5745 and attributeid = @attributeid
5746 "
5747
5748 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5749 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5750
5751 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5752 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5753
5754 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::DateTime) | Out-Null
5755 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
5756
5757 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5758 $cmd = (ConvertTo-OracleCommand $cmd)
5759 }
5760
5761 $cmd.Connection = $dbConn
5762
5763 $rowsAffected = $cmd.ExecuteNonQuery()
5764
5765 return $rowsAffected
5766 }
5767 catch {
5768 throw ("Error in Update-TaskAttrDate: " + $error[0])
5769 }
5770} # Update-TaskAttrDate
5771
5772
5773Function Insert-TaskAttrDate ($attr, $dbConn) {
5774 try {
5775 $cmd = New-Object System.Data.SqlClient.SqlCommand
5776
5777 $cmd.CommandText = "
5778 insert into TaskAttrDate (taskid, attributeid, datevalue)
5779 values (@taskid, @attributeid, @value)
5780 "
5781
5782 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5783 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5784
5785 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5786 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5787
5788 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::DateTime) | Out-Null
5789 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
5790
5791 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5792 $cmd = (ConvertTo-OracleCommand $cmd)
5793 }
5794
5795 $cmd.Connection = $dbConn
5796
5797 $rowsAffected = $cmd.ExecuteNonQuery()
5798
5799 return $rowsAffected
5800 }
5801 catch {
5802 throw ("Error in Insert-TaskAttrDate: " + $error[0])
5803 }
5804} # Insert-TaskAttrDate
5805
5806
5807Function Delete-TaskAttrDate ($attr, $dbConn) {
5808 try {
5809 $cmd = New-Object System.Data.SqlClient.SqlCommand
5810
5811 $cmd.CommandText = "
5812 delete TaskAttrDate where taskid = @taskid and attributeid = @attributeid
5813 "
5814
5815 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5816 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5817
5818 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5819 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5820
5821 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5822 $cmd = (ConvertTo-OracleCommand $cmd)
5823 }
5824
5825 $cmd.Connection = $dbConn
5826
5827 $rowsAffected = $cmd.ExecuteNonQuery()
5828
5829 return $rowsAffected
5830 }
5831 catch {
5832 throw ("Error in Delete-TaskAttrDate: " + $error[0])
5833 }
5834} # Delete-TaskAttrDate
5835
5836
5837$global:diffQueries["TaskAttrFloat_MasterNotAtSat"] = "
5838 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5839 select @satelliteid, 'TaskAttrFloat', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
5840 from {MasterPrefix}TaskAttrFloat{MasterSuffix} attr_mast
5841 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
5842 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
5843 where f_mast.owner = @satelliteid
5844 and not exists (
5845 select 1
5846 from {SatellitePrefix}TaskAttrFloat{SatelliteSuffix}
5847 where taskid = attr_mast.taskid
5848 and attributeid = attr_mast.attributeid
5849 )
5850"
5851
5852$global:diffQueries["TaskAttrFloat_SatNotAtMaster"] = "
5853 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5854 select @satelliteid, 'TaskAttrFloat', attr_sat.taskid, attr_sat.attributeid, 'Unprocessed', @statustime
5855 from {SatellitePrefix}TaskAttrFloat{SatelliteSuffix} attr_sat
5856 where not exists (
5857 select 1
5858 from {MasterPrefix}TaskAttrFloat{MasterSuffix}
5859 where taskid = attr_sat.taskid
5860 and attributeid = attr_sat.attributeid
5861 )
5862"
5863
5864$global:diffQueries["TaskAttrFloat_MasterSatDiff"] = "
5865 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
5866 select @satelliteid, 'TaskAttrFloat', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
5867 from {MasterPrefix}TaskAttrFloat{MasterSuffix} attr_mast
5868 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
5869 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
5870 join {SatellitePrefix}TaskAttrFloat{SatelliteSuffix} attr_sat on attr_sat.taskid = attr_mast.taskid and attr_sat.attributeid = attr_mast.attributeid
5871 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = attr_sat.taskid
5872 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
5873 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
5874 and (
5875 attr_mast.floatvalue <> attr_sat.floatvalue
5876 or attr_mast.floatvalue is null and attr_sat.floatvalue is not null
5877 or attr_mast.floatvalue is not null and attr_sat.floatvalue is null
5878 )
5879"
5880
5881
5882Function Merge-TaskAttrFloat ($attr1, $attr2) {
5883 try {
5884 return $attr1
5885 }
5886 catch {
5887 throw ("Error in Merge-TaskAttrFloat: " + $error[0])
5888 }
5889} # Merge-TaskAttrFloat
5890
5891
5892# Create blank object once, so it can be copied to create new instances.
5893# This results in huge performance gains.
5894$global:blankTaskAttrFloat = $global:blankItem.PSObject.Copy()
5895$global:blankTaskAttrFloat.ItemType = "TaskAttrFloat"
5896$global:blankTaskAttrFloat | Add-Member NoteProperty Value $null
5897
5898Function Select-TaskAttrFloat ($taskId, $attributeId, $dbConn) {
5899 try {
5900 $cmd = New-Object System.Data.SqlClient.SqlCommand
5901
5902 $cmd.CommandText = "
5903 select f.owner, a.floatvalue
5904 from TaskAttrFloat a
5905 join Task t on t.taskid = a.taskid
5906 join Files f on f.fileid = t.fileid
5907 where a.taskid = @taskid
5908 and a.attributeid = @attributeid
5909 "
5910
5911 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5912 $cmd.Parameters["@taskid"].Value = $taskId
5913
5914 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5915 $cmd.Parameters["@attributeid"].Value = $attributeId
5916
5917 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5918 $cmd = (ConvertTo-OracleCommand $cmd)
5919 }
5920
5921 $cmd.Connection = $dbConn
5922
5923 $reader = $cmd.ExecuteReader()
5924
5925 if ($reader.Read()) {
5926 $attr = $global:blankTaskAttrFloat.PSObject.Copy()
5927
5928 $attr.ItemId = $taskId
5929 $attr.ItemId2 = $attributeId
5930 $attr.Owner = ConvertTo-PsType $reader[0]
5931 $attr.Value = ConvertTo-PsType $reader[1]
5932 }
5933 else {
5934 $attr = $null
5935 }
5936
5937 return $attr
5938 }
5939 catch {
5940 throw ("Error in Select-TaskAttrFloat: " + $error[0])
5941 }
5942 finally {
5943 if ($reader) {$reader.Close()}
5944 }
5945} # Select-TaskAttrFloat
5946
5947
5948Function Update-TaskAttrFloat ($attr, $dbConn) {
5949 try {
5950 $cmd = New-Object System.Data.SqlClient.SqlCommand
5951
5952 $cmd.CommandText = "
5953 update TaskAttrFloat
5954 set floatvalue = @value
5955 where taskid = @taskid
5956 and attributeid = @attributeid
5957 "
5958
5959 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5960 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5961
5962 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5963 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5964
5965 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Float) | Out-Null
5966 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
5967
5968 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
5969 $cmd = (ConvertTo-OracleCommand $cmd)
5970 }
5971
5972 $cmd.Connection = $dbConn
5973
5974 $rowsAffected = $cmd.ExecuteNonQuery()
5975
5976 return $rowsAffected
5977 }
5978 catch {
5979 throw ("Error in Update-TaskAttrFloat: " + $error[0])
5980 }
5981} # Update-TaskAttrFloat
5982
5983
5984Function Insert-TaskAttrFloat ($attr, $dbConn) {
5985 try {
5986 $cmd = New-Object System.Data.SqlClient.SqlCommand
5987
5988 $cmd.CommandText = "
5989 insert into TaskAttrFloat (taskid, attributeid, floatvalue)
5990 values (@taskid, @attributeid, @value)
5991 "
5992
5993 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
5994 $cmd.Parameters["@taskid"].Value = $attr.ItemId
5995
5996 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
5997 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
5998
5999 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Float) | Out-Null
6000 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
6001
6002 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6003 $cmd = (ConvertTo-OracleCommand $cmd)
6004 }
6005
6006 $cmd.Connection = $dbConn
6007
6008 $rowsAffected = $cmd.ExecuteNonQuery()
6009
6010 return $rowsAffected
6011 }
6012 catch {
6013 throw ("Error in Insert-TaskAttrFloat: " + $error[0])
6014 }
6015} # Insert-TaskAttrFloat
6016
6017
6018Function Delete-TaskAttrFloat ($attr, $dbConn) {
6019 try {
6020 $cmd = New-Object System.Data.SqlClient.SqlCommand
6021
6022 $cmd.CommandText = "
6023 delete TaskAttrFloat where taskid = @taskid and attributeid = @attributeid
6024 "
6025
6026 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6027 $cmd.Parameters["@taskid"].Value = $attr.ItemId
6028
6029 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
6030 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
6031
6032 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6033 $cmd = (ConvertTo-OracleCommand $cmd)
6034 }
6035
6036 $cmd.Connection = $dbConn
6037
6038 $rowsAffected = $cmd.ExecuteNonQuery()
6039
6040 return $rowsAffected
6041 }
6042 catch {
6043 throw ("Error in Delete-TaskAttrFloat: " + $error[0])
6044 }
6045} # Delete-TaskAttrFloat
6046
6047
6048$global:diffQueries["TaskAttrInt_MasterNotAtSat"] = "
6049 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6050 select @satelliteid, 'TaskAttrInt', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
6051 from {MasterPrefix}TaskAttrInt{MasterSuffix} attr_mast
6052 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
6053 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
6054 where f_mast.owner = @satelliteid
6055 and not exists (
6056 select 1
6057 from {SatellitePrefix}TaskAttrInt{SatelliteSuffix}
6058 where taskid = attr_mast.taskid
6059 and attributeid = attr_mast.attributeid
6060 )
6061"
6062
6063$global:diffQueries["TaskAttrInt_SatNotAtMaster"] = "
6064 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6065 select @satelliteid, 'TaskAttrInt', attr_sat.taskid, attr_sat.attributeid, 'Unprocessed', @statustime
6066 from {SatellitePrefix}TaskAttrInt{SatelliteSuffix} attr_sat
6067 where not exists (
6068 select 1
6069 from {MasterPrefix}TaskAttrInt{MasterSuffix}
6070 where taskid = attr_sat.taskid
6071 and attributeid = attr_sat.attributeid
6072 )
6073"
6074
6075$global:diffQueries["TaskAttrInt_MasterSatDiff"] = "
6076 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6077 select @satelliteid, 'TaskAttrInt', attr_mast.taskid, attr_mast.attributeid, 'Unprocessed', @statustime
6078 from {MasterPrefix}TaskAttrInt{MasterSuffix} attr_mast
6079 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = attr_mast.taskid
6080 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
6081 join {SatellitePrefix}TaskAttrInt{SatelliteSuffix} attr_sat on attr_sat.taskid = attr_mast.taskid and attr_sat.attributeid = attr_mast.attributeid
6082 join {SatellitePrefix}Task{SatelliteSuffix} t_sat on t_sat.taskid = attr_sat.taskid
6083 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = t_sat.fileid
6084 where (f_mast.owner = @satelliteid or f_sat.owner = @satelliteid)
6085 and (
6086 attr_mast.intvalue <> attr_sat.intvalue
6087 or attr_mast.intvalue is null and attr_sat.intvalue is not null
6088 or attr_mast.intvalue is not null and attr_sat.intvalue is null
6089 )
6090"
6091
6092
6093Function Merge-TaskAttrInt ($attr1, $attr2) {
6094 try {
6095 return $attr1
6096 }
6097 catch {
6098 throw ("Error in Merge-TaskAttrInt: " + $error[0])
6099 }
6100} # Merge-TaskAttrInt
6101
6102
6103# Create blank object once, so it can be copied to create new instances.
6104# This results in huge performance gains.
6105$global:blankTaskAttrInt = $global:blankItem.PSObject.Copy()
6106$global:blankTaskAttrInt.ItemType = "TaskAttrInt"
6107$global:blankTaskAttrInt | Add-Member NoteProperty Value $null
6108
6109Function Select-TaskAttrInt ($taskId, $attributeId, $dbConn) {
6110 try {
6111 $cmd = New-Object System.Data.SqlClient.SqlCommand
6112
6113 $cmd.CommandText = "
6114 select f.owner, a.intvalue
6115 from TaskAttrInt a
6116 join Task t on t.taskid = a.taskid
6117 join Files f on f.fileid = t.fileid
6118 where a.taskid = @taskid
6119 and a.attributeid = @attributeid
6120 "
6121
6122 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6123 $cmd.Parameters["@taskid"].Value = $taskId
6124
6125 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
6126 $cmd.Parameters["@attributeid"].Value = $attributeId
6127
6128 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6129 $cmd = (ConvertTo-OracleCommand $cmd)
6130 }
6131
6132 $cmd.Connection = $dbConn
6133
6134 $reader = $cmd.ExecuteReader()
6135
6136 if ($reader.Read()) {
6137 $attr = $global:blankTaskAttrInt.PSObject.Copy()
6138
6139 $attr.ItemId = $taskId
6140 $attr.ItemId2 = $attributeId
6141 $attr.Owner = ConvertTo-PsType $reader[0]
6142 $attr.Value = ConvertTo-PsType $reader[1]
6143 }
6144 else {
6145 $attr = $null
6146 }
6147
6148 return $attr
6149 }
6150 catch {
6151 throw ("Error in Select-TaskAttrInt: " + $error[0])
6152 }
6153 finally {
6154 if ($reader) {$reader.Close()}
6155 }
6156} # Select-TaskAttrInt
6157
6158
6159Function Update-TaskAttrInt ($attr, $dbConn) {
6160 try {
6161 $cmd = New-Object System.Data.SqlClient.SqlCommand
6162
6163 $cmd.CommandText = "
6164 update TaskAttrInt
6165 set intvalue = @value
6166 where taskid = @taskid
6167 and attributeid = @attributeid
6168 "
6169
6170 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6171 $cmd.Parameters["@taskid"].Value = $attr.ItemId
6172
6173 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
6174 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
6175
6176 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Int) | Out-Null
6177 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
6178
6179 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6180 $cmd = (ConvertTo-OracleCommand $cmd)
6181 }
6182
6183 $cmd.Connection = $dbConn
6184
6185 $rowsAffected = $cmd.ExecuteNonQuery()
6186
6187 return $rowsAffected
6188 }
6189 catch {
6190 throw ("Error in Update-TaskAttrInt: " + $error[0])
6191 }
6192} # Update-TaskAttrInt
6193
6194
6195Function Insert-TaskAttrInt ($attr, $dbConn) {
6196 try {
6197 $cmd = New-Object System.Data.SqlClient.SqlCommand
6198
6199 $cmd.CommandText = "
6200 insert into TaskAttrInt (taskid, attributeid, intvalue)
6201 values (@taskid, @attributeid, @value)
6202 "
6203
6204 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6205 $cmd.Parameters["@taskid"].Value = $attr.ItemId
6206
6207 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
6208 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
6209
6210 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Int) | Out-Null
6211 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
6212
6213 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6214 $cmd = (ConvertTo-OracleCommand $cmd)
6215 }
6216
6217 $cmd.Connection = $dbConn
6218
6219 $rowsAffected = $cmd.ExecuteNonQuery()
6220
6221 return $rowsAffected
6222 }
6223 catch {
6224 throw ("Error in Insert-TaskAttrInt: " + $error[0])
6225 }
6226} # Insert-TaskAttrInt
6227
6228
6229Function Delete-TaskAttrInt ($attr, $dbConn) {
6230 try {
6231 $cmd = New-Object System.Data.SqlClient.SqlCommand
6232
6233 $cmd.CommandText = "
6234 delete TaskAttrInt where taskid = @taskid and attributeid = @attributeid
6235 "
6236
6237 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6238 $cmd.Parameters["@taskid"].Value = $attr.ItemId
6239
6240 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
6241 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
6242
6243 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6244 $cmd = (ConvertTo-OracleCommand $cmd)
6245 }
6246
6247 $cmd.Connection = $dbConn
6248
6249 $rowsAffected = $cmd.ExecuteNonQuery()
6250
6251 return $rowsAffected
6252 }
6253 catch {
6254 throw ("Error in Delete-TaskAttrInt: " + $error[0])
6255 }
6256} # Delete-TaskAttrInt
6257
6258
6259$global:diffQueries["TaskMaster_MasterNotAtSat"] = "
6260 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6261 select @satelliteid, 'TaskMaster', tm_mast.taskid, null, 'Unprocessed', @statustime
6262 from {MasterPrefix}TaskMaster{MasterSuffix} tm_mast
6263 join {MasterPrefix}Task{MasterSuffix} t_mast on t_mast.taskid = tm_mast.taskid
6264 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = t_mast.fileid
6265 where f_mast.owner = @satelliteid
6266 and not exists (
6267 select 1
6268 from {SatellitePrefix}TaskMaster{SatelliteSuffix}
6269 where taskid = tm_mast.taskid
6270 )
6271"
6272
6273$global:diffQueries["TaskMaster_SatNotAtMaster"] = "
6274 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6275 select @satelliteid, 'TaskMaster', tm_sat.taskid, null, 'Unprocessed', @statustime
6276 from {SatellitePrefix}TaskMaster{SatelliteSuffix} tm_sat
6277 where not exists (
6278 select 1
6279 from {MasterPrefix}TaskMaster{MasterSuffix}
6280 where taskid = tm_sat.taskid
6281 )
6282"
6283
6284$global:diffQueries["TaskMaster_MasterSatDiff"] = "
6285 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6286 select @satelliteid, 'TaskMaster', tm_mast.taskid, null, 'Unprocessed', @statustime
6287 from {MasterPrefix}TaskMaster{MasterSuffix} tm_mast
6288 join {SatellitePrefix}TaskMaster{SatelliteSuffix} tm_sat on tm_sat.taskid = tm_mast.taskid
6289 where tm_mast.dateinitiated <> tm_sat.dateinitiated
6290 or tm_mast.imagesetid <> tm_sat.imagesetid
6291 or tm_mast.imagesetid is null and tm_sat.imagesetid is not null
6292 or tm_mast.dateended <> tm_sat.dateended
6293 or tm_mast.dateended is null and tm_sat.dateended is not null
6294 or tm_mast.dateended is not null and tm_sat.dateended is null
6295"
6296
6297
6298Function Merge-TaskMaster ($taskMaster1, $taskMaster2) {
6299 try {
6300 $taskMaster1.MinOperationTime = Merge-Value $taskMaster1.MinOperationTime $taskMaster2.MinOperationTime "ReplaceNull" "Lesser"
6301 $taskMaster1.MaxOperationTime = Merge-Value $taskMaster1.MaxOperationTime $taskMaster2.MaxOperationTime "ReplaceNull" "Greater"
6302
6303 $taskMaster1.DateInitiated = Merge-Value $taskMaster1.MinOperationTime $taskMaster2.MinOperationTime "ReplaceNull" "Lesser"
6304 $taskMaster1.ImageSetId = Merge-Value $taskMaster1.ImageSetId $taskMaster2.ImageSetId "ReplaceNull"
6305
6306 # The task will only have an owner if there is an active task record, which means dateended should be null. If
6307 # there is not an active task record, the task has been completed.
6308 if ($taskMaster1.Owner -eq $taskMaster1.SiteId) {
6309 $taskMaster1.DateEnded = $null
6310 }
6311 else {
6312 $taskMaster1.DateEnded = Merge-Value $taskMaster1.MaxOperationTime $taskMaster2.MaxOperationTime "ReplaceNull" "Greater"
6313 }
6314
6315 return $taskMaster1
6316 }
6317 catch {
6318 throw ("Error in Merge-TaskMaster: " + $error[0])
6319 }
6320} # Merge-TaskMaster
6321
6322
6323# Create blank object once, so it can be copied to create new instances.
6324# This results in huge performance gains.
6325$global:blankTaskMaster = $global:blankItem.PSObject.Copy()
6326$global:blankTaskMaster.ItemType = "TaskMaster"
6327$global:blankTaskMaster | Add-Member NoteProperty DateInitiated $null
6328$global:blankTaskMaster | Add-Member NoteProperty ImageSetId $null
6329$global:blankTaskMaster | Add-Member NoteProperty DateEnded $null
6330$global:blankTaskMaster | Add-Member NoteProperty MinOperationTime $null
6331$global:blankTaskMaster | Add-Member NoteProperty MaxOperationTime $null
6332
6333Function Select-TaskMaster ($taskId, $dbConn) {
6334 try {
6335 $cmd = New-Object System.Data.SqlClient.SqlCommand
6336
6337 $cmd.CommandText = "
6338 select f.owner, tm.dateinitiated, tm.imagesetid, tm.dateended,
6339 min(tha.operationtime), max(tha.operationtime)
6340 from TaskMaster tm (nolock)
6341 left join Task t (nolock) on t.taskid = tm.taskid
6342 left join Files f (nolock) on f.fileid = t.fileid
6343 left join TaskHistory th (nolock) on th.taskid = tm.taskid
6344 left join TaskHistoryAction tha (nolock) on tha.historyid = th.historyid
6345 where tm.taskid = @taskid
6346 group by f.owner, tm.dateinitiated, tm.imagesetid, tm.dateended
6347 "
6348
6349 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6350 $cmd.Parameters["@taskid"].Value = $taskId
6351
6352 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6353 $cmd = (ConvertTo-OracleCommand $cmd)
6354 }
6355
6356 $cmd.Connection = $dbConn
6357
6358 $reader = $cmd.ExecuteReader()
6359
6360 if ($reader.Read()) {
6361 $taskMaster = $global:blankTaskMaster.PSObject.Copy()
6362
6363 $taskMaster.ItemId = $taskId
6364 $taskMaster.ItemId2 = $null
6365 $taskMaster.Owner = ConvertTo-PsType $reader[0]
6366 $taskMaster.DateInitiated = ConvertTo-PsType $reader[1]
6367 $taskMaster.ImageSetId = ConvertTo-PsType $reader[2]
6368 $taskMaster.DateEnded = ConvertTo-PsType $reader[3]
6369 $taskMaster.MinOperationTime = ConvertTo-PsType $reader[4]
6370 $taskMaster.MaxOperationTime = ConvertTo-PsType $reader[5]
6371 }
6372 else {
6373 $taskMaster = $null
6374 }
6375
6376 return $taskMaster
6377 }
6378 catch {
6379 throw ("Error in Select-TaskMaster: " + $error[0])
6380 }
6381 finally {
6382 if ($reader) {$reader.Close()}
6383 }
6384} # Select-TaskMaster
6385
6386
6387Function Update-TaskMaster ($taskMaster, $dbConn) {
6388 try {
6389 $cmd = New-Object System.Data.SqlClient.SqlCommand
6390
6391 $cmd.CommandText = "
6392 update TaskMaster
6393 set dateinitiated = @dateinitiated, imagesetid = @imagesetid, dateended = @dateended
6394 where taskid = @taskid
6395 "
6396
6397 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6398 $cmd.Parameters["@taskid"].Value = $taskMaster.ItemId
6399
6400 $cmd.Parameters.Add("@dateinitiated", [System.Data.SqlDbType]::DateTime) | Out-Null
6401 $cmd.Parameters["@dateinitiated"].Value = $taskMaster.DateInitiated
6402
6403 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
6404 $cmd.Parameters["@imagesetid"].Value = ConvertTo-DbNull $taskMaster.ImageSetId
6405
6406 $cmd.Parameters.Add("@dateended", [System.Data.SqlDbType]::DateTime) | Out-Null
6407 $cmd.Parameters["@dateended"].Value = ConvertTo-DbNull $taskMaster.DateEnded
6408
6409 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6410 $cmd = (ConvertTo-OracleCommand $cmd)
6411 }
6412
6413 $cmd.Connection = $dbConn
6414
6415 $rowsAffected = $cmd.ExecuteNonQuery()
6416
6417 return $rowsAffected
6418 }
6419 catch {
6420 throw ("Error in Update-TaskMaster: " + $error[0])
6421 }
6422} # Update-TaskMaster
6423
6424
6425Function Insert-TaskMaster ($taskMaster, $dbConn) {
6426 try {
6427 $cmd = New-Object System.Data.SqlClient.SqlCommand
6428
6429 $cmd.CommandText = "
6430 insert into TaskMaster (taskid, dateinitiated, imagesetid, dateended)
6431 values (@taskid, @dateinitiated, @imagesetid, @dateended)
6432 "
6433
6434 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6435 $cmd.Parameters["@taskid"].Value = $taskMaster.ItemId
6436
6437 $cmd.Parameters.Add("@dateinitiated", [System.Data.SqlDbType]::DateTime) | Out-Null
6438 $cmd.Parameters["@dateinitiated"].Value = $taskMaster.DateInitiated
6439
6440 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
6441 $cmd.Parameters["@imagesetid"].Value = ConvertTo-DbNull $taskMaster.ImageSetId
6442
6443 $cmd.Parameters.Add("@dateended", [System.Data.SqlDbType]::DateTime) | Out-Null
6444 $cmd.Parameters["@dateended"].Value = ConvertTo-DbNull $taskMaster.DateEnded
6445
6446 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6447 $cmd = (ConvertTo-OracleCommand $cmd)
6448 }
6449
6450 $cmd.Connection = $dbConn
6451
6452 $rowsAffected = $cmd.ExecuteNonQuery()
6453
6454 return $rowsAffected
6455 }
6456 catch {
6457 throw ("Error in Insert-TaskMaster: " + $error[0])
6458 }
6459} # Insert-TaskMaster
6460
6461
6462$global:diffQueries["TaskHistory_SatNotAtMaster"] = "
6463 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6464 select @satelliteid, 'TaskHistory', th_sat.historyid, null, 'Unprocessed', @statustime
6465 from {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat
6466 where not exists (
6467 select 1
6468 from {MasterPrefix}TaskHistory{MasterSuffix}
6469 where historyid = th_sat.historyid
6470 )
6471"
6472
6473$global:diffQueries["TaskHistory_MasterSatDiff"] = "
6474 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6475 select @satelliteid, 'TaskHistory', th_mast.historyid, null, 'Unprocessed', @statustime
6476 from {MasterPrefix}TaskHistory{MasterSuffix} th_mast
6477 join {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat on th_sat.historyid = th_mast.historyid
6478 where th_mast.taskid <> th_sat.taskid
6479 or th_mast.historytimeid <> th_sat.historytimeid
6480 or th_mast.fileid <> th_sat.fileid
6481 or th_mast.assignedto <> th_sat.assignedto
6482 or th_mast.assignedto is null and th_sat.assignedto is not null
6483 or th_mast.assignedto is not null and th_sat.assignedto is null
6484 or th_mast.objectid <> th_sat.objectid
6485 or th_mast.pageid <> th_sat.pageid
6486 or th_mast.pageid is null and th_sat.pageid is not null
6487 or th_mast.pageid is not null and th_sat.pageid is null
6488 or th_mast.priority <> th_sat.priority
6489 or th_mast.debug <> th_sat.debug
6490 or th_mast.description <> th_sat.description
6491 or th_mast.description is null and th_sat.description is not null
6492 or th_mast.description is not null and th_sat.description is null
6493 or th_mast.dateavailable <> th_sat.dateavailable
6494 or th_mast.dateavailable is null and th_sat.dateavailable is not null
6495 or th_mast.dateavailable is not null and th_sat.dateavailable is null
6496 or th_mast.deadline <> th_sat.deadline
6497 or th_mast.deadline is null and th_sat.deadline is not null
6498 or th_mast.deadline is not null and th_sat.deadline is null
6499 or th_mast.statusdetails <> th_sat.statusdetails
6500 or th_mast.statusdetails is null and th_sat.statusdetails is not null
6501 or th_mast.statusdetails is not null and th_sat.statusdetails is null
6502 or th_mast.stacklevel <> th_sat.stacklevel
6503 or th_mast.stacklevel is null and th_sat.stacklevel is not null
6504 or th_mast.stacklevel is not null and th_sat.stacklevel is null
6505 or th_mast.sender <> th_sat.sender
6506 or th_mast.sender is null and th_sat.sender is not null
6507 or th_mast.sender is not null and th_sat.sender is null
6508 or th_mast.senderstep <> th_sat.senderstep
6509 or th_mast.senderstep is null and th_sat.senderstep is not null
6510 or th_mast.senderstep is not null and th_sat.senderstep is null
6511 or th_mast.noteid <> th_sat.noteid
6512 or th_mast.noteid is null and th_sat.noteid is not null
6513 or th_mast.noteid is not null and th_sat.noteid is null
6514 or th_mast.supertaskid <> th_sat.supertaskid
6515 or th_mast.supertaskid is null and th_sat.supertaskid is not null
6516 or th_mast.supertaskid is not null and th_sat.supertaskid is null
6517"
6518
6519
6520Function Merge-TaskHistory ($taskHistory1, $taskHistory2) {
6521 try {
6522 $taskHistory1.StackLevel = Merge-Value $taskHistory1.StackLevel $taskHistory2.StackLevel "ReplaceNull"
6523
6524 return $taskHistory1
6525 }
6526 catch {
6527 throw ("Error in Merge-TaskHistory: " + $error[0])
6528 }
6529} # Merge-TaskHistory
6530
6531
6532# Create blank object once, so it can be copied to create new instances.
6533# This results in huge performance gains.
6534$global:blankTaskHistory = $global:blankItem.PSObject.Copy()
6535$global:blankTaskHistory.ItemType = "TaskHistory"
6536$global:blankTaskHistory | Add-Member NoteProperty TaskId $null
6537$global:blankTaskHistory | Add-Member NoteProperty HistoryTimeId $null
6538$global:blankTaskHistory | Add-Member NoteProperty FileId $null
6539$global:blankTaskHistory | Add-Member NoteProperty AssignedTo $null
6540$global:blankTaskHistory | Add-Member NoteProperty ObjectId $null
6541$global:blankTaskHistory | Add-Member NoteProperty PageId $null
6542$global:blankTaskHistory | Add-Member NoteProperty Priority $null
6543$global:blankTaskHistory | Add-Member NoteProperty Debug $null
6544$global:blankTaskHistory | Add-Member NoteProperty Description $null
6545$global:blankTaskHistory | Add-Member NoteProperty DateAvailable $null
6546$global:blankTaskHistory | Add-Member NoteProperty Deadline $null
6547$global:blankTaskHistory | Add-Member NoteProperty StatusDetails $null
6548$global:blankTaskHistory | Add-Member NoteProperty StackLevel $null
6549$global:blankTaskHistory | Add-Member NoteProperty Sender $null
6550$global:blankTaskHistory | Add-Member NoteProperty SenderStep $null
6551$global:blankTaskHistory | Add-Member NoteProperty NoteId $null
6552$global:blankTaskHistory | Add-Member NoteProperty SuperTaskId $null
6553
6554
6555Function Select-TaskHistory ($historyId, $dbConn) {
6556 try {
6557 $cmd = New-Object System.Data.SqlClient.SqlCommand
6558
6559 $cmd.CommandText = "
6560 select f.owner, th.taskid, th.historytimeid, th.fileid, th.assignedto, th.objectid, th.pageid, th.priority,
6561 th.debug, th.description, th.dateavailable, th.deadline, th.statusdetails, th.stacklevel, th.sender,
6562 th.senderstep, th.noteid, th.supertaskid
6563 from TaskHistory th
6564 join Files f on f.fileid = th.fileid
6565 where th.historyid = @historyid
6566 "
6567
6568 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
6569 $cmd.Parameters["@historyid"].Value = $historyId
6570
6571 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6572 $cmd = (ConvertTo-OracleCommand $cmd)
6573 }
6574
6575 $cmd.Connection = $dbConn
6576
6577 $reader = $cmd.ExecuteReader()
6578
6579 if ($reader.Read()) {
6580 $taskHistory = $global:blankTaskHistory.PSObject.Copy()
6581
6582 $taskHistory.ItemId = $historyId
6583 $taskHistory.ItemId2 = $null
6584 $taskHistory.Owner = ConvertTo-PsType $reader[0]
6585 $taskHistory.TaskId = ConvertTo-PsType $reader[1]
6586 $taskHistory.HistoryTimeId = ConvertTo-PsType $reader[2]
6587 $taskHistory.FileId = ConvertTo-PsType $reader[3]
6588 $taskHistory.AssignedTo = ConvertTo-PsType $reader[4]
6589 $taskHistory.ObjectId = ConvertTo-PsType $reader[5]
6590 $taskHistory.PageId = ConvertTo-PsType $reader[6]
6591 $taskHistory.Priority = ConvertTo-PsType $reader[7]
6592 $taskHistory.Debug = ConvertTo-PsType $reader[8]
6593 $taskHistory.Description = ConvertTo-PsType $reader[9]
6594 $taskHistory.DateAvailable = ConvertTo-PsType $reader[10]
6595 $taskHistory.Deadline = ConvertTo-PsType $reader[11]
6596 $taskHistory.StatusDetails = ConvertTo-PsType $reader[12]
6597 $taskHistory.StackLevel = ConvertTo-PsType $reader[13]
6598 $taskHistory.Sender = ConvertTo-PsType $reader[14]
6599 $taskHistory.SenderStep = ConvertTo-PsType $reader[15]
6600 $taskHistory.NoteId = ConvertTo-PsType $reader[16]
6601 $taskHistory.SuperTaskId = ConvertTo-PsType $reader[17]
6602 }
6603 else {
6604 $taskHistory = $null
6605 }
6606
6607 return $taskHistory
6608 }
6609 catch {
6610 throw ("Error in Select-TaskHistory: " + $error[0])
6611 }
6612 finally {
6613 if ($reader) {$reader.Close()}
6614 }
6615} # Select-TaskHistory
6616
6617
6618Function Update-TaskHistory ($history, $dbConn) {
6619 try {
6620 $cmd = New-Object System.Data.SqlClient.SqlCommand
6621
6622 $cmd.CommandText = "
6623 update TaskHistory
6624 set taskid = @taskid, historytimeid = @historytimeid, fileid = @fileid,
6625 assignedto = @assignedto, objectid = @objectid, pageid = @pageid, priority = @priority,
6626 debug = @debug, description = @description, dateavailable = @dateavailable,
6627 deadline = @deadline, statusdetails = @statusdetails, stacklevel = @stacklevel,
6628 sender = @sender, senderstep = @senderstep, noteid = @noteid, supertaskid = @supertaskid
6629 where historyid = @historyid
6630 "
6631
6632 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
6633 $cmd.Parameters["@historyid"].Value = $history.ItemId
6634
6635 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6636 $cmd.Parameters["@taskid"].Value = $history.TaskId
6637
6638 $cmd.Parameters.Add("@historytimeid", [System.Data.SqlDbType]::Int) | Out-Null
6639 $cmd.Parameters["@historytimeid"].Value = $history.HistoryTimeId
6640
6641 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
6642 $cmd.Parameters["@fileid"].Value = $history.FileId
6643
6644 $cmd.Parameters.Add("@assignedto", [System.Data.SqlDbType]::Int) | Out-Null
6645 $cmd.Parameters["@assignedto"].Value = ConvertTo-DbNull $history.AssignedTo
6646
6647 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
6648 $cmd.Parameters["@objectid"].Value = $history.ObjectId
6649
6650 $cmd.Parameters.Add("@pageid", [System.Data.SqlDbType]::Int) | Out-Null
6651 $cmd.Parameters["@pageid"].Value = ConvertTo-DbNull $history.PageId
6652
6653 $cmd.Parameters.Add("@priority", [System.Data.SqlDbType]::Int) | Out-Null
6654 $cmd.Parameters["@priority"].Value = $history.Priority
6655
6656 $cmd.Parameters.Add("@debug", [System.Data.SqlDbType]::Int) | Out-Null
6657 $cmd.Parameters["@debug"].Value = $history.Debug
6658
6659 $cmd.Parameters.Add("@description", [System.Data.SqlDbType]::VarChar) | Out-Null
6660 $cmd.Parameters["@description"].Value = ConvertTo-DbNull $history.Description
6661
6662 $cmd.Parameters.Add("@dateavailable", [System.Data.SqlDbType]::DateTime) | Out-Null
6663 $cmd.Parameters["@dateavailable"].Value = ConvertTo-DbNull $history.DateAvailable
6664
6665 $cmd.Parameters.Add("@deadline", [System.Data.SqlDbType]::DateTime) | Out-Null
6666 $cmd.Parameters["@deadline"].Value = ConvertTo-DbNull $history.Deadline
6667
6668 $cmd.Parameters.Add("@statusdetails", [System.Data.SqlDbType]::Int) | Out-Null
6669 $cmd.Parameters["@statusdetails"].Value = ConvertTo-DbNull $history.StatusDetails
6670
6671 $cmd.Parameters.Add("@stacklevel", [System.Data.SqlDbType]::Int) | Out-Null
6672 $cmd.Parameters["@stacklevel"].Value = ConvertTo-DbNull $history.StackLevel
6673
6674 $cmd.Parameters.Add("@sender", [System.Data.SqlDbType]::Int) | Out-Null
6675 $cmd.Parameters["@sender"].Value = ConvertTo-DbNull $history.Sender
6676
6677 $cmd.Parameters.Add("@senderstep", [System.Data.SqlDbType]::Int) | Out-Null
6678 $cmd.Parameters["@senderstep"].Value = ConvertTo-DbNull $history.SenderStep
6679
6680 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
6681 $cmd.Parameters["@noteid"].Value = ConvertTo-DbNull $history.NoteId
6682
6683 $cmd.Parameters.Add("@supertaskid", [System.Data.SqlDbType]::Int) | Out-Null
6684 $cmd.Parameters["@supertaskid"].Value = ConvertTo-DbNull $history.SuperTaskId
6685
6686 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6687 $cmd = (ConvertTo-OracleCommand $cmd)
6688
6689 if ($history.Description -eq "") {$cmd.Parameters["@description"].Value = " "}
6690 }
6691
6692 $cmd.Connection = $dbConn
6693
6694 $rowsAffected = $cmd.ExecuteNonQuery()
6695
6696 return $rowsAffected
6697 }
6698 catch {
6699 throw ("Error in Update-TaskHistory: " + $error[0])
6700 }
6701} # Update-TaskHistory
6702
6703
6704Function Insert-TaskHistory ($history, $dbConn) {
6705 try {
6706 $cmd = New-Object System.Data.SqlClient.SqlCommand
6707
6708 $cmd.CommandText = "
6709 insert into TaskHistory (
6710 historyid, taskid, historytimeid, fileid, assignedto, objectid, pageid, priority,
6711 debug, description, dateavailable, deadline, statusdetails, stacklevel, sender,
6712 senderstep, noteid, supertaskid
6713 )
6714 values (
6715 @historyid, @taskid, @historytimeid, @fileid, @assignedto, @objectid, @pageid, @priority,
6716 @debug, @description, @dateavailable, @deadline, @statusdetails, @stacklevel, @sender,
6717 @senderstep, @noteid, @supertaskid
6718 )
6719 "
6720
6721 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
6722 $cmd.Parameters["@historyid"].Value = $history.ItemId
6723
6724 $cmd.Parameters.Add("@taskid", [System.Data.SqlDbType]::Int) | Out-Null
6725 $cmd.Parameters["@taskid"].Value = $history.TaskId
6726
6727 $cmd.Parameters.Add("@historytimeid", [System.Data.SqlDbType]::Int) | Out-Null
6728 $cmd.Parameters["@historytimeid"].Value = $history.HistoryTimeId
6729
6730 $cmd.Parameters.Add("@fileid", [System.Data.SqlDbType]::Int) | Out-Null
6731 $cmd.Parameters["@fileid"].Value = $history.FileId
6732
6733 $cmd.Parameters.Add("@assignedto", [System.Data.SqlDbType]::Int) | Out-Null
6734 $cmd.Parameters["@assignedto"].Value = ConvertTo-DbNull $history.AssignedTo
6735
6736 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
6737 $cmd.Parameters["@objectid"].Value = $history.ObjectId
6738
6739 $cmd.Parameters.Add("@pageid", [System.Data.SqlDbType]::Int) | Out-Null
6740 $cmd.Parameters["@pageid"].Value = ConvertTo-DbNull $history.PageId
6741
6742 $cmd.Parameters.Add("@priority", [System.Data.SqlDbType]::Int) | Out-Null
6743 $cmd.Parameters["@priority"].Value = $history.Priority
6744
6745 $cmd.Parameters.Add("@debug", [System.Data.SqlDbType]::Int) | Out-Null
6746 $cmd.Parameters["@debug"].Value = $history.Debug
6747
6748 $cmd.Parameters.Add("@description", [System.Data.SqlDbType]::VarChar) | Out-Null
6749 $cmd.Parameters["@description"].Value = ConvertTo-DbNull $history.Description
6750
6751 $cmd.Parameters.Add("@dateavailable", [System.Data.SqlDbType]::DateTime) | Out-Null
6752 $cmd.Parameters["@dateavailable"].Value = ConvertTo-DbNull $history.DateAvailable
6753
6754 $cmd.Parameters.Add("@deadline", [System.Data.SqlDbType]::DateTime) | Out-Null
6755 $cmd.Parameters["@deadline"].Value = ConvertTo-DbNull $history.Deadline
6756
6757 $cmd.Parameters.Add("@statusdetails", [System.Data.SqlDbType]::Int) | Out-Null
6758 $cmd.Parameters["@statusdetails"].Value = ConvertTo-DbNull $history.StatusDetails
6759
6760 $cmd.Parameters.Add("@stacklevel", [System.Data.SqlDbType]::Int) | Out-Null
6761 $cmd.Parameters["@stacklevel"].Value = ConvertTo-DbNull $history.StackLevel
6762
6763 $cmd.Parameters.Add("@sender", [System.Data.SqlDbType]::Int) | Out-Null
6764 $cmd.Parameters["@sender"].Value = ConvertTo-DbNull $history.Sender
6765
6766 $cmd.Parameters.Add("@senderstep", [System.Data.SqlDbType]::Int) | Out-Null
6767 $cmd.Parameters["@senderstep"].Value = ConvertTo-DbNull $history.SenderStep
6768
6769 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
6770 $cmd.Parameters["@noteid"].Value = ConvertTo-DbNull $history.NoteId
6771
6772 $cmd.Parameters.Add("@supertaskid", [System.Data.SqlDbType]::Int) | Out-Null
6773 $cmd.Parameters["@supertaskid"].Value = ConvertTo-DbNull $history.SuperTaskId
6774
6775 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6776 $cmd = (ConvertTo-OracleCommand $cmd)
6777 }
6778
6779 $cmd.Connection = $dbConn
6780
6781 $cmd.ExecuteNonQuery() | Out-Null
6782 }
6783 catch {
6784 throw ("Error in Insert-TaskHistory: " + $error[0])
6785 }
6786} # Insert-TaskHistory
6787
6788
6789$global:diffQueries["TaskHistoryTime_SatNotAtMaster"] = "
6790 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6791 select @satelliteid, 'TaskHistoryTime', tht_sat.historytimeid, null, 'Unprocessed', @statustime
6792 from {SatellitePrefix}TaskHistoryTime{SatelliteSuffix} tht_sat
6793 where not exists (
6794 select 1
6795 from {MasterPrefix}TaskHistoryTime{MasterSuffix}
6796 where historytimeid = tht_sat.historytimeid
6797 )
6798"
6799
6800$global:diffQueries["TaskHistoryTime_MasterSatDiff"] = "
6801 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6802 select @satelliteid, 'TaskHistoryTime', tht_mast.historytimeid, null, 'Unprocessed', @statustime
6803 from {MasterPrefix}TaskHistoryTime{MasterSuffix} tht_mast
6804 join {SatellitePrefix}TaskHistoryTime{SatelliteSuffix} tht_sat on tht_sat.historytimeid = tht_mast.historytimeid
6805 where tht_mast.steprootid <> tht_sat.steprootid
6806 or tht_mast.starttime <> tht_sat.starttime
6807 or tht_mast.endtime <> tht_sat.endtime
6808 or tht_mast.endtime is null and tht_sat.endtime is not null
6809 or tht_mast.endtime is not null and tht_sat.endtime is null
6810"
6811
6812
6813Function Merge-TaskHistoryTime ($tht1, $tht2) {
6814 try {
6815 $tht1.MinOperationTime = Merge-Value $tht1.MinOperationTime $tht2.MinOperationTime "ReplaceNull" "Lesser"
6816 $tht1.MaxOperationTime = Merge-Value $tht1.MaxOperationTime $tht2.MaxOperationTime "ReplaceNull" "Greater"
6817
6818 $tht1.StartTime = Merge-Value $tht1.MinOperationTime $tht2.MinOperationTime "ReplaceNull" "Lesser"
6819 $tht1.EndTime = Merge-Value $tht1.MaxOperationTime $tht2.MaxOperationTime "ReplaceNull" "Greater"
6820
6821 return $tht1
6822 }
6823 catch {
6824 throw ("Error in Merge-TaskHistoryTime: " + $error[0])
6825 }
6826} # Merge-TaskHistoryTime
6827
6828
6829# Create blank object once, so it can be copied to create new instances.
6830# This results in huge performance gains.
6831$global:blankTaskHistoryTime = $global:blankItem.PSObject.Copy()
6832$global:blankTaskHistoryTime.ItemType = "TaskHistoryTime"
6833$global:blankTaskHistoryTime | Add-Member NoteProperty StepRootId $null
6834$global:blankTaskHistoryTime | Add-Member NoteProperty StartTime $null
6835$global:blankTaskHistoryTime | Add-Member NoteProperty EndTime $null
6836$global:blankTaskHistoryTime | Add-Member NoteProperty MinOperationTime $null
6837$global:blankTaskHistoryTime | Add-Member NoteProperty MaxOperationTime $null
6838
6839Function Select-TaskHistoryTime ($historyTimeId, $dbConn) {
6840 try {
6841 $cmd = New-Object System.Data.SqlClient.SqlCommand
6842
6843 $cmd.CommandText = "
6844 select null, tht.steprootid, tht.starttime, tht.endtime, min(tha.operationtime), max(tha.operationtime)
6845 from TaskHistoryTime tht (nolock)
6846 left join TaskHistory th (nolock) on th.historytimeid = tht.historytimeid
6847 left join TaskHistoryAction tha (nolock) on tha.historyid = th.historyid
6848 where tht.historytimeid = @historytimeid
6849 group by tht.steprootid, tht.starttime, tht.endtime
6850 "
6851
6852 $cmd.Parameters.Add("@historytimeid", [System.Data.SqlDbType]::Int) | Out-Null
6853 $cmd.Parameters["@historytimeid"].Value = $historyTimeId
6854
6855 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6856 $cmd = (ConvertTo-OracleCommand $cmd)
6857 }
6858
6859 $cmd.Connection = $dbConn
6860
6861 $reader = $cmd.ExecuteReader()
6862
6863 if ($reader.Read()) {
6864 $tht = $global:blankTaskHistoryTime.PSObject.Copy()
6865
6866 $tht.ItemId = $historyTimeId
6867 $tht.ItemId2 = $null
6868 $tht.Owner = ConvertTo-PsType $reader[0]
6869 $tht.StepRootId = ConvertTo-PsType $reader[1]
6870 $tht.StartTime = ConvertTo-PsType $reader[2]
6871 $tht.EndTime = ConvertTo-PsType $reader[3]
6872 $tht.MinOperationTime = ConvertTo-PsType $reader[4]
6873 $tht.MaxOperationTime = ConvertTo-PsType $reader[5]
6874 }
6875 else {
6876 $tht = $null
6877 }
6878
6879 return $tht
6880 }
6881 catch {
6882 throw ("Error in Select-TaskHistoryTime: " + $error[0])
6883 }
6884 finally {
6885 if ($reader) {$reader.Close()}
6886 }
6887} # Select-TaskHistoryTime
6888
6889
6890Function Update-TaskHistoryTime ($tht, $dbConn) {
6891 try {
6892 $cmd = New-Object System.Data.SqlClient.SqlCommand
6893
6894 $cmd.CommandText = "
6895 update TaskHistoryTime
6896 set steprootid = @steprootid, starttime = @starttime, endtime = @endtime
6897 where historytimeid = @historytimeid
6898 "
6899
6900 $cmd.Parameters.Add("@historytimeid", [System.Data.SqlDbType]::Int) | Out-Null
6901 $cmd.Parameters["@historytimeid"].Value = $tht.ItemId
6902
6903 $cmd.Parameters.Add("@steprootid", [System.Data.SqlDbType]::Int) | Out-Null
6904 $cmd.Parameters["@steprootid"].Value = $tht.StepRootId
6905
6906 $cmd.Parameters.Add("@starttime", [System.Data.SqlDbType]::DateTime) | Out-Null
6907 $cmd.Parameters["@starttime"].Value = $tht.StartTime
6908
6909 $cmd.Parameters.Add("@endtime", [System.Data.SqlDbType]::DateTime) | Out-Null
6910 $cmd.Parameters["@endtime"].Value = ConvertTo-DbNull $tht.EndTime
6911
6912 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6913 $cmd = (ConvertTo-OracleCommand $cmd)
6914 }
6915
6916 $cmd.Connection = $dbConn
6917
6918 $rowsAffected = $cmd.ExecuteNonQuery()
6919
6920 return $rowsAffected
6921 }
6922 catch {
6923 throw ("Error in Update-TaskHistoryTime: " + $error[0])
6924 }
6925} # Update-TaskHistoryTime
6926
6927
6928Function Insert-TaskHistoryTime ($tht, $dbConn) {
6929 try {
6930 $cmd = New-Object System.Data.SqlClient.SqlCommand
6931
6932 $cmd.CommandText = "
6933 insert into TaskHistoryTime (historytimeid, steprootid, starttime, endtime)
6934 values (@historytimeid, @steprootid, @starttime, @endtime)
6935 "
6936
6937 $cmd.Parameters.Add("@historytimeid", [System.Data.SqlDbType]::Int) | Out-Null
6938 $cmd.Parameters["@historytimeid"].Value = $tht.ItemId
6939
6940 $cmd.Parameters.Add("@steprootid", [System.Data.SqlDbType]::Int) | Out-Null
6941 $cmd.Parameters["@steprootid"].Value = $tht.StepRootId
6942
6943 $cmd.Parameters.Add("@starttime", [System.Data.SqlDbType]::DateTime) | Out-Null
6944 $cmd.Parameters["@starttime"].Value = $tht.StartTime
6945
6946 $cmd.Parameters.Add("@endtime", [System.Data.SqlDbType]::DateTime) | Out-Null
6947 $cmd.Parameters["@endtime"].Value = ConvertTo-DbNull $tht.EndTime
6948
6949 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
6950 $cmd = (ConvertTo-OracleCommand $cmd)
6951 }
6952
6953 $cmd.Connection = $dbConn
6954
6955 $cmd.ExecuteNonQuery() | Out-Null
6956 }
6957 catch {
6958 throw ("Error in Insert-TaskHistoryTime: " + $error[0])
6959 }
6960} # Insert-TaskHistoryTime
6961
6962
6963$global:diffQueries["TaskHistoryAttrBinary_SatNotAtMaster"] = "
6964 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6965 select @satelliteid, 'TaskHistoryAttrBinary', attr_sat.historyid, attr_sat.attributeid, 'Unprocessed', @statustime
6966 from {SatellitePrefix}TaskHistoryAttrBinary{SatelliteSuffix} attr_sat
6967 where not exists (
6968 select 1
6969 from {MasterPrefix}TaskHistoryAttrBinary{MasterSuffix}
6970 where historyid = attr_sat.historyid
6971 and attributeid = attr_sat.attributeid
6972 )
6973"
6974
6975$global:diffQueries["TaskHistoryAttrBinary_MasterSatDiff"] = "
6976 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
6977 select @satelliteid, 'TaskHistoryAttrBinary', attr_mast.historyid, attr_mast.attributeid, 'Unprocessed', @statustime
6978 from {MasterPrefix}TaskHistoryAttrBinary{MasterSuffix} attr_mast
6979 join {MasterPrefix}TaskHistory{MasterSuffix} th_mast on th_mast.historyid = attr_mast.historyid
6980 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = th_mast.fileid
6981 join {SatellitePrefix}TaskHistoryAttrBinary{SatelliteSuffix} attr_sat on attr_sat.historyid = attr_mast.historyid and attr_sat.attributeid = attr_mast.attributeid
6982 join {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat on th_sat.historyid = attr_sat.historyid
6983 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = th_sat.fileid
6984 where cast(attr_mast.binaryvalue as varbinary(max)) <> cast(attr_sat.binaryvalue as varbinary(max))
6985 or attr_mast.binaryvalue is null and attr_sat.binaryvalue is not null
6986 or attr_mast.binaryvalue is not null and attr_sat.binaryvalue is null
6987 or attr_mast.operation <> attr_sat.operation
6988"
6989
6990
6991Function Merge-TaskHistoryAttrBinary ($attr1, $attr2) {
6992 try {
6993 return $attr1
6994 }
6995 catch {
6996 throw ("Error in Merge-TaskHistoryAttrBinary: " + $error[0])
6997 }
6998} # Merge-TaskHistoryAttrBinary
6999
7000
7001# Create blank object once, so it can be copied to create new instances.
7002# This results in huge performance gains.
7003$global:blankTaskHistoryAttrBinary = $global:blankItem.PSObject.Copy()
7004$global:blankTaskHistoryAttrBinary.ItemType = "TaskHistoryAttrBinary"
7005$global:blankTaskHistoryAttrBinary | Add-Member NoteProperty Value $null
7006$global:blankTaskHistoryAttrBinary | Add-Member NoteProperty Operation $null
7007
7008Function Select-TaskHistoryAttrBinary ($historyId, $attributeId, $dbConn) {
7009 try {
7010 $cmd = New-Object System.Data.SqlClient.SqlCommand
7011
7012 $cmd.CommandText = "
7013 select f.owner, a.binaryvalue, a.operation
7014 from TaskHistoryAttrBinary a
7015 join TaskHistory th on th.historyid = a.historyid
7016 join Files f on f.fileid = th.fileid
7017 where a.historyid = @historyid
7018 and a.attributeid = @attributeid
7019 "
7020
7021 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7022 $cmd.Parameters["@historyid"].Value = $historyId
7023
7024 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7025 $cmd.Parameters["@attributeid"].Value = $attributeId
7026
7027 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7028 $cmd = (ConvertTo-OracleCommand $cmd)
7029 }
7030
7031 $cmd.Connection = $dbConn
7032
7033 $reader = $cmd.ExecuteReader()
7034
7035 if ($reader.Read()) {
7036 $attr = $global:blankTaskHistoryAttrBinary.PSObject.Copy()
7037
7038 $attr.ItemId = $historyId
7039 $attr.ItemId2 = $attributeId
7040 $attr.Owner = ConvertTo-PsType $reader[0]
7041 $attr.Value = ConvertTo-PsType $reader[1]
7042 $attr.Operation = ConvertTo-PsType $reader[2]
7043 }
7044 else {
7045 $attr = $null
7046 }
7047
7048 return $attr
7049 }
7050 catch {
7051 throw ("Error in Select-TaskHistoryAttrBinary: " + $error[0])
7052 }
7053 finally {
7054 if ($reader) {$reader.Close()}
7055 }
7056} # Select-TaskHistoryAttrBinary
7057
7058
7059Function Update-TaskHistoryAttrBinary ($attr, $dbConn) {
7060 try {
7061 $cmd = New-Object System.Data.SqlClient.SqlCommand
7062
7063 $cmd.CommandText = "
7064 update TaskHistoryAttrBinary
7065 set binaryvalue = @value, operation = @operation
7066 where historyid = @historyid
7067 and attributeid = @attributeid
7068 "
7069
7070 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7071 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7072
7073 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7074 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7075
7076 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Image) | Out-Null
7077 if ($attr.Value -ne $null) {$cmd.Parameters["@value"].Value = [byte[]]$attr.Value}
7078 else {$cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)}
7079
7080 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7081 $cmd.Parameters["@operation"].Value = $attr.Operation
7082
7083 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7084 $cmd = (ConvertTo-OracleCommand $cmd)
7085 }
7086
7087 $cmd.Connection = $dbConn
7088
7089 $rowsAffected = $cmd.ExecuteNonQuery()
7090
7091 return $rowsAffected
7092 }
7093 catch {
7094 throw ("Error in Update-TaskHistoryAttrBinary: " + $error[0])
7095 }
7096} # Update-TaskHistoryAttrBinary
7097
7098
7099Function Insert-TaskHistoryAttrBinary ($attr, $dbConn) {
7100 try {
7101 $cmd = New-Object System.Data.SqlClient.SqlCommand
7102
7103 $cmd.CommandText = "
7104 insert into TaskHistoryAttrBinary (historyid, attributeid, binaryvalue, operation)
7105 values (@historyid, @attributeid, @value, @operation)
7106 "
7107
7108 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7109 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7110
7111 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7112 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7113
7114 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Image) | Out-Null
7115 if ($attr.Value -ne $null) {$cmd.Parameters["@value"].Value = [byte[]]$attr.Value}
7116 else {$cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)}
7117
7118 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7119 $cmd.Parameters["@operation"].Value = $attr.Operation
7120
7121 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7122 $cmd = (ConvertTo-OracleCommand $cmd)
7123 }
7124
7125 $cmd.Connection = $dbConn
7126
7127 $rowsAffected = $cmd.ExecuteNonQuery()
7128
7129 return $rowsAffected
7130 }
7131 catch {
7132 throw ("Error in Insert-TaskHistoryAttrBinary: " + $error[0])
7133 }
7134} # Insert-TaskHistoryAttrBinary
7135
7136
7137$global:diffQueries["TaskHistoryAttrChar_SatNotAtMaster"] = "
7138 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7139 select @satelliteid, 'TaskHistoryAttrChar', attr_sat.historyid, attr_sat.attributeid, 'Unprocessed', @statustime
7140 from {SatellitePrefix}TaskHistoryAttrChar{SatelliteSuffix} attr_sat
7141 where not exists (
7142 select 1
7143 from {MasterPrefix}TaskHistoryAttrChar{MasterSuffix}
7144 where historyid = attr_sat.historyid
7145 and attributeid = attr_sat.attributeid
7146 )
7147"
7148
7149$global:diffQueries["TaskHistoryAttrChar_MasterSatDiff"] = "
7150 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7151 select @satelliteid, 'TaskHistoryAttrChar', attr_mast.historyid, attr_mast.attributeid, 'Unprocessed', @statustime
7152 from {MasterPrefix}TaskHistoryAttrChar{MasterSuffix} attr_mast
7153 join {MasterPrefix}TaskHistory{MasterSuffix} th_mast on th_mast.historyid = attr_mast.historyid
7154 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = th_mast.fileid
7155 join {SatellitePrefix}TaskHistoryAttrChar{SatelliteSuffix} attr_sat on attr_sat.historyid = attr_mast.historyid and attr_sat.attributeid = attr_mast.attributeid
7156 join {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat on th_sat.historyid = attr_sat.historyid
7157 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = th_sat.fileid
7158 where attr_mast.charvalue <> attr_sat.charvalue
7159 or attr_mast.charvalue is null and attr_sat.charvalue is not null
7160 or attr_mast.charvalue is not null and attr_sat.charvalue is null
7161 or attr_mast.operation <> attr_sat.operation
7162"
7163
7164
7165Function Merge-TaskHistoryAttrChar ($attr1, $attr2) {
7166 try {
7167 return $attr1
7168 }
7169 catch {
7170 throw ("Error in Merge-TaskHistoryAttrChar: " + $error[0])
7171 }
7172} # Merge-TaskHistoryAttrChar
7173
7174
7175# Create blank object once, so it can be copied to create new instances.
7176# This results in huge performance gains.
7177$global:blankTaskHistoryAttrChar = $global:blankItem.PSObject.Copy()
7178$global:blankTaskHistoryAttrChar.ItemType = "TaskHistoryAttrChar"
7179$global:blankTaskHistoryAttrChar | Add-Member NoteProperty Value $null
7180$global:blankTaskHistoryAttrChar | Add-Member NoteProperty Operation $null
7181
7182Function Select-TaskHistoryAttrChar ($historyId, $attributeId, $dbConn) {
7183 try {
7184 $cmd = New-Object System.Data.SqlClient.SqlCommand
7185
7186 $cmd.CommandText = "
7187 select f.owner, a.charvalue, a.operation
7188 from TaskHistoryAttrChar a
7189 join TaskHistory th on th.historyid = a.historyid
7190 join Files f on f.fileid = th.fileid
7191 where a.historyid = @historyid
7192 and a.attributeid = @attributeid
7193 "
7194
7195 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7196 $cmd.Parameters["@historyid"].Value = $historyId
7197
7198 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7199 $cmd.Parameters["@attributeid"].Value = $attributeId
7200
7201 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7202 $cmd = (ConvertTo-OracleCommand $cmd)
7203 }
7204
7205 $cmd.Connection = $dbConn
7206
7207 $reader = $cmd.ExecuteReader()
7208
7209 if ($reader.Read()) {
7210 $attr = $global:blankTaskHistoryAttrChar.PSObject.Copy()
7211
7212 $attr.ItemId = $historyId
7213 $attr.ItemId2 = $attributeId
7214 $attr.Owner = ConvertTo-PsType $reader[0]
7215 $attr.Value = ConvertTo-PsType $reader[1]
7216 $attr.Operation = ConvertTo-PsType $reader[2]
7217 }
7218 else {
7219 $attr = $null
7220 }
7221
7222 return $attr
7223 }
7224 catch {
7225 throw ("Error in Select-TaskHistoryAttrChar: " + $error[0])
7226 }
7227 finally {
7228 if ($reader) {$reader.Close()}
7229 }
7230} # Select-TaskHistoryAttrChar
7231
7232
7233Function Update-TaskHistoryAttrChar ($attr, $dbConn) {
7234 try {
7235 $cmd = New-Object System.Data.SqlClient.SqlCommand
7236
7237 $cmd.CommandText = "
7238 update TaskHistoryAttrChar
7239 set charvalue = @value, operation = @operation
7240 where historyid = @historyid
7241 and attributeid = @attributeid
7242 "
7243
7244 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7245 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7246
7247 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7248 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7249
7250 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::VarChar) | Out-Null
7251 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
7252
7253 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7254 $cmd.Parameters["@operation"].Value = $attr.Operation
7255
7256 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7257 $cmd = (ConvertTo-OracleCommand $cmd)
7258 }
7259
7260 $cmd.Connection = $dbConn
7261
7262 $rowsAffected = $cmd.ExecuteNonQuery()
7263
7264 return $rowsAffected
7265 }
7266 catch {
7267 throw ("Error in Update-TaskHistoryAttrChar: " + $error[0])
7268 }
7269} # Update-TaskHistoryAttrChar
7270
7271
7272Function Insert-TaskHistoryAttrChar ($attr, $dbConn) {
7273 try {
7274 $cmd = New-Object System.Data.SqlClient.SqlCommand
7275
7276 $cmd.CommandText = "
7277 insert into TaskHistoryAttrChar (historyid, attributeid, charvalue, operation)
7278 values (@historyid, @attributeid, @value, @operation)
7279 "
7280
7281 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7282 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7283
7284 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7285 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7286
7287 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::VarChar) | Out-Null
7288 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
7289
7290 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7291 $cmd.Parameters["@operation"].Value = $attr.Operation
7292
7293 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7294 $cmd = (ConvertTo-OracleCommand $cmd)
7295 }
7296
7297 $cmd.Connection = $dbConn
7298
7299 $rowsAffected = $cmd.ExecuteNonQuery()
7300
7301 return $rowsAffected
7302 }
7303 catch {
7304 throw ("Error in Insert-TaskHistoryAttrChar: " + $error[0])
7305 }
7306} # Insert-TaskHistoryAttrChar
7307
7308
7309$global:diffQueries["TaskHistoryAttrDate_SatNotAtMaster"] = "
7310 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7311 select @satelliteid, 'TaskHistoryAttrDate', attr_sat.historyid, attr_sat.attributeid, 'Unprocessed', @statustime
7312 from {SatellitePrefix}TaskHistoryAttrDate{SatelliteSuffix} attr_sat
7313 where not exists (
7314 select 1
7315 from {MasterPrefix}TaskHistoryAttrDate{MasterSuffix}
7316 where historyid = attr_sat.historyid
7317 and attributeid = attr_sat.attributeid
7318 )
7319"
7320
7321$global:diffQueries["TaskHistoryAttrDate_MasterSatDiff"] = "
7322 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7323 select @satelliteid, 'TaskHistoryAttrDate', attr_mast.historyid, attr_mast.attributeid, 'Unprocessed', @statustime
7324 from {MasterPrefix}TaskHistoryAttrDate{MasterSuffix} attr_mast
7325 join {MasterPrefix}TaskHistory{MasterSuffix} th_mast on th_mast.historyid = attr_mast.historyid
7326 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = th_mast.fileid
7327 join {SatellitePrefix}TaskHistoryAttrDate{SatelliteSuffix} attr_sat on attr_sat.historyid = attr_mast.historyid and attr_sat.attributeid = attr_mast.attributeid
7328 join {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat on th_sat.historyid = attr_sat.historyid
7329 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = th_sat.fileid
7330 where attr_mast.datevalue <> attr_sat.datevalue
7331 or attr_mast.datevalue is null and attr_sat.datevalue is not null
7332 or attr_mast.datevalue is not null and attr_sat.datevalue is null
7333 or attr_mast.operation <> attr_sat.operation
7334"
7335
7336
7337Function Merge-TaskHistoryAttrDate ($attr1, $attr2) {
7338 try {
7339 return $attr1
7340 }
7341 catch {
7342 throw ("Error in Merge-TaskHistoryAttrDate: " + $error[0])
7343 }
7344} # Merge-TaskHistoryAttrDate
7345
7346
7347# Create blank object once, so it can be copied to create new instances.
7348# This results in huge performance gains.
7349$global:blankTaskHistoryAttrDate = $global:blankItem.PSObject.Copy()
7350$global:blankTaskHistoryAttrDate.ItemType = "TaskHistoryAttrDate"
7351$global:blankTaskHistoryAttrDate | Add-Member NoteProperty Value $null
7352$global:blankTaskHistoryAttrDate | Add-Member NoteProperty Operation $null
7353
7354Function Select-TaskHistoryAttrDate ($historyId, $attributeId, $dbConn) {
7355 try {
7356 $cmd = New-Object System.Data.SqlClient.SqlCommand
7357
7358 $cmd.CommandText = "
7359 select f.owner, a.datevalue, a.operation
7360 from TaskHistoryAttrDate a
7361 join TaskHistory th on th.historyid = a.historyid
7362 join Files f on f.fileid = th.fileid
7363 where a.historyid = @historyid
7364 and a.attributeid = @attributeid
7365 "
7366
7367 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7368 $cmd.Parameters["@historyid"].Value = $historyId
7369
7370 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7371 $cmd.Parameters["@attributeid"].Value = $attributeId
7372
7373 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7374 $cmd = (ConvertTo-OracleCommand $cmd)
7375 }
7376
7377 $cmd.Connection = $dbConn
7378
7379 $reader = $cmd.ExecuteReader()
7380
7381 if ($reader.Read()) {
7382 $attr = $global:blankTaskHistoryAttrDate.PSObject.Copy()
7383
7384 $attr.ItemId = $historyId
7385 $attr.ItemId2 = $attributeId
7386 $attr.Owner = ConvertTo-PsType $reader[0]
7387 $attr.Value = ConvertTo-PsType $reader[1]
7388 $attr.Operation = ConvertTo-PsType $reader[2]
7389 }
7390 else {
7391 $attr = $null
7392 }
7393
7394 return $attr
7395 }
7396 catch {
7397 throw ("Error in Select-TaskHistoryAttrDate: " + $error[0])
7398 }
7399 finally {
7400 if ($reader) {$reader.Close()}
7401 }
7402} # Select-TaskHistoryAttrDate
7403
7404
7405Function Update-TaskHistoryAttrDate ($attr, $dbConn) {
7406 try {
7407 $cmd = New-Object System.Data.SqlClient.SqlCommand
7408
7409 $cmd.CommandText = "
7410 update TaskHistoryAttrDate
7411 set datevalue = @value, operation = @operation
7412 where historyid = @historyid
7413 and attributeid = @attributeid
7414 "
7415
7416 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7417 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7418
7419 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7420 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7421
7422 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::DateTime) | Out-Null
7423 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
7424
7425 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7426 $cmd.Parameters["@operation"].Value = $attr.Operation
7427
7428 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7429 $cmd = (ConvertTo-OracleCommand $cmd)
7430 }
7431
7432 $cmd.Connection = $dbConn
7433
7434 $rowsAffected = $cmd.ExecuteNonQuery()
7435
7436 return $rowsAffected
7437 }
7438 catch {
7439 throw ("Error in Update-TaskHistoryAttrDate: " + $error[0])
7440 }
7441} # Update-TaskHistoryAttrDate
7442
7443
7444Function Insert-TaskHistoryAttrDate ($attr, $dbConn) {
7445 try {
7446 $cmd = New-Object System.Data.SqlClient.SqlCommand
7447
7448 $cmd.CommandText = "
7449 insert into TaskHistoryAttrDate (historyid, attributeid, datevalue, operation)
7450 values (@historyid, @attributeid, @value, @operation)
7451 "
7452
7453 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7454 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7455
7456 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7457 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7458
7459 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::DateTime) | Out-Null
7460 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
7461
7462 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7463 $cmd.Parameters["@operation"].Value = $attr.Operation
7464
7465 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7466 $cmd = (ConvertTo-OracleCommand $cmd)
7467 }
7468
7469 $cmd.Connection = $dbConn
7470
7471 $rowsAffected = $cmd.ExecuteNonQuery()
7472
7473 return $rowsAffected
7474 }
7475 catch {
7476 throw ("Error in Insert-TaskHistoryAttrDate: " + $error[0])
7477 }
7478} # Insert-TaskHistoryAttrDate
7479
7480
7481$global:diffQueries["TaskHistoryAttrFloat_SatNotAtMaster"] = "
7482 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7483 select @satelliteid, 'TaskHistoryAttrFloat', attr_sat.historyid, attr_sat.attributeid, 'Unprocessed', @statustime
7484 from {SatellitePrefix}TaskHistoryAttrFloat{SatelliteSuffix} attr_sat
7485 where not exists (
7486 select 1
7487 from {MasterPrefix}TaskHistoryAttrFloat{MasterSuffix}
7488 where historyid = attr_sat.historyid
7489 and attributeid = attr_sat.attributeid
7490 )
7491"
7492
7493$global:diffQueries["TaskHistoryAttrFloat_MasterSatDiff"] = "
7494 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7495 select @satelliteid, 'TaskHistoryAttrFloat', attr_mast.historyid, attr_mast.attributeid, 'Unprocessed', @statustime
7496 from {MasterPrefix}TaskHistoryAttrFloat{MasterSuffix} attr_mast
7497 join {MasterPrefix}TaskHistory{MasterSuffix} th_mast on th_mast.historyid = attr_mast.historyid
7498 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = th_mast.fileid
7499 join {SatellitePrefix}TaskHistoryAttrFloat{SatelliteSuffix} attr_sat on attr_sat.historyid = attr_mast.historyid and attr_sat.attributeid = attr_mast.attributeid
7500 join {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat on th_sat.historyid = attr_sat.historyid
7501 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = th_sat.fileid
7502 where attr_mast.floatvalue <> attr_sat.floatvalue
7503 or attr_mast.floatvalue is null and attr_sat.floatvalue is not null
7504 or attr_mast.floatvalue is not null and attr_sat.floatvalue is null
7505 or attr_mast.operation <> attr_sat.operation
7506"
7507
7508
7509Function Merge-TaskHistoryAttrFloat ($attr1, $attr2) {
7510 try {
7511 return $attr1
7512 }
7513 catch {
7514 throw ("Error in Merge-TaskHistoryAttrFloat: " + $error[0])
7515 }
7516} # Merge-TaskHistoryAttrFloat
7517
7518
7519# Create blank object once, so it can be copied to create new instances.
7520# This results in huge performance gains.
7521$global:blankTaskHistoryAttrFloat = $global:blankItem.PSObject.Copy()
7522$global:blankTaskHistoryAttrFloat.ItemType = "TaskHistoryAttrFloat"
7523$global:blankTaskHistoryAttrFloat | Add-Member NoteProperty Value $null
7524$global:blankTaskHistoryAttrFloat | Add-Member NoteProperty Operation $null
7525
7526Function Select-TaskHistoryAttrFloat ($historyId, $attributeId, $dbConn) {
7527 try {
7528 $cmd = New-Object System.Data.SqlClient.SqlCommand
7529
7530 $cmd.CommandText = "
7531 select f.owner, a.floatvalue, a.operation
7532 from TaskHistoryAttrFloat a
7533 join TaskHistory th on th.historyid = a.historyid
7534 join Files f on f.fileid = th.fileid
7535 where a.historyid = @historyid
7536 and a.attributeid = @attributeid
7537 "
7538
7539 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7540 $cmd.Parameters["@historyid"].Value = $historyId
7541
7542 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7543 $cmd.Parameters["@attributeid"].Value = $attributeId
7544
7545 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7546 $cmd = (ConvertTo-OracleCommand $cmd)
7547 }
7548
7549 $cmd.Connection = $dbConn
7550
7551 $reader = $cmd.ExecuteReader()
7552
7553 if ($reader.Read()) {
7554 $attr = $global:blankTaskHistoryAttrFloat.PSObject.Copy()
7555
7556 $attr.ItemId = $historyId
7557 $attr.ItemId2 = $attributeId
7558 $attr.Owner = ConvertTo-PsType $reader[0]
7559 $attr.Value = ConvertTo-PsType $reader[1]
7560 $attr.Operation = ConvertTo-PsType $reader[2]
7561 }
7562 else {
7563 $attr = $null
7564 }
7565
7566 return $attr
7567 }
7568 catch {
7569 throw ("Error in Select-TaskHistoryAttrFloat: " + $error[0])
7570 }
7571 finally {
7572 if ($reader) {$reader.Close()}
7573 }
7574} # Select-TaskHistoryAttrFloat
7575
7576
7577Function Update-TaskHistoryAttrFloat ($attr, $dbConn) {
7578 try {
7579 $cmd = New-Object System.Data.SqlClient.SqlCommand
7580
7581 $cmd.CommandText = "
7582 update TaskHistoryAttrFloat
7583 set floatvalue = @value, operation = @operation
7584 where historyid = @historyid
7585 and attributeid = @attributeid
7586 "
7587
7588 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7589 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7590
7591 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7592 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7593
7594 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Float) | Out-Null
7595 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
7596
7597 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7598 $cmd.Parameters["@operation"].Value = $attr.Operation
7599
7600 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7601 $cmd = (ConvertTo-OracleCommand $cmd)
7602 }
7603
7604 $cmd.Connection = $dbConn
7605
7606 $rowsAffected = $cmd.ExecuteNonQuery()
7607
7608 return $rowsAffected
7609 }
7610 catch {
7611 throw ("Error in Update-TaskHistoryAttrFloat: " + $error[0])
7612 }
7613} # Update-TaskHistoryAttrFloat
7614
7615
7616Function Insert-TaskHistoryAttrFloat ($attr, $dbConn) {
7617 try {
7618 $cmd = New-Object System.Data.SqlClient.SqlCommand
7619
7620 $cmd.CommandText = "
7621 insert into TaskHistoryAttrFloat (historyid, attributeid, floatvalue, operation)
7622 values (@historyid, @attributeid, @value, @operation)
7623 "
7624
7625 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7626 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7627
7628 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7629 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7630
7631 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Float) | Out-Null
7632 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
7633
7634 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7635 $cmd.Parameters["@operation"].Value = $attr.Operation
7636
7637 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7638 $cmd = (ConvertTo-OracleCommand $cmd)
7639 }
7640
7641 $cmd.Connection = $dbConn
7642
7643 $rowsAffected = $cmd.ExecuteNonQuery()
7644
7645 return $rowsAffected
7646 }
7647 catch {
7648 throw ("Error in Insert-TaskHistoryAttrFloat: " + $error[0])
7649 }
7650} # Insert-TaskHistoryAttrFloat
7651
7652
7653$global:diffQueries["TaskHistoryAttrInt_SatNotAtMaster"] = "
7654 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7655 select @satelliteid, 'TaskHistoryAttrInt', attr_sat.historyid, attr_sat.attributeid, 'Unprocessed', @statustime
7656 from {SatellitePrefix}TaskHistoryAttrInt{SatelliteSuffix} attr_sat
7657 where not exists (
7658 select 1
7659 from {MasterPrefix}TaskHistoryAttrInt{MasterSuffix}
7660 where historyid = attr_sat.historyid
7661 and attributeid = attr_sat.attributeid
7662 )
7663"
7664
7665$global:diffQueries["TaskHistoryAttrInt_MasterSatDiff"] = "
7666 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7667 select @satelliteid, 'TaskHistoryAttrInt', attr_mast.historyid, attr_mast.attributeid, 'Unprocessed', @statustime
7668 from {MasterPrefix}TaskHistoryAttrInt{MasterSuffix} attr_mast
7669 join {MasterPrefix}TaskHistory{MasterSuffix} th_mast on th_mast.historyid = attr_mast.historyid
7670 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = th_mast.fileid
7671 join {SatellitePrefix}TaskHistoryAttrInt{SatelliteSuffix} attr_sat on attr_sat.historyid = attr_mast.historyid and attr_sat.attributeid = attr_mast.attributeid
7672 join {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat on th_sat.historyid = attr_sat.historyid
7673 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = th_sat.fileid
7674 where attr_mast.intvalue <> attr_sat.intvalue
7675 or attr_mast.intvalue is null and attr_sat.intvalue is not null
7676 or attr_mast.intvalue is not null and attr_sat.intvalue is null
7677 or attr_mast.operation <> attr_sat.operation
7678"
7679
7680
7681Function Merge-TaskHistoryAttrInt ($attr1, $attr2) {
7682 try {
7683 return $attr1
7684 }
7685 catch {
7686 throw ("Error in Merge-TaskHistoryAttrInt: " + $error[0])
7687 }
7688} # Merge-TaskHistoryAttrInt
7689
7690
7691# Create blank object once, so it can be copied to create new instances.
7692# This results in huge performance gains.
7693$global:blankTaskHistoryAttrInt = $global:blankItem.PSObject.Copy()
7694$global:blankTaskHistoryAttrInt.ItemType = "TaskHistoryAttrInt"
7695$global:blankTaskHistoryAttrInt | Add-Member NoteProperty Value $null
7696$global:blankTaskHistoryAttrInt | Add-Member NoteProperty Operation $null
7697
7698Function Select-TaskHistoryAttrInt ($historyId, $attributeId, $dbConn) {
7699 try {
7700 $cmd = New-Object System.Data.SqlClient.SqlCommand
7701
7702 $cmd.CommandText = "
7703 select f.owner, a.intvalue, a.operation
7704 from TaskHistoryAttrInt a
7705 join TaskHistory th on th.historyid = a.historyid
7706 join Files f on f.fileid = th.fileid
7707 where a.historyid = @historyid
7708 and a.attributeid = @attributeid
7709 "
7710
7711 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7712 $cmd.Parameters["@historyid"].Value = $historyId
7713
7714 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7715 $cmd.Parameters["@attributeid"].Value = $attributeId
7716
7717 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7718 $cmd = (ConvertTo-OracleCommand $cmd)
7719 }
7720
7721 $cmd.Connection = $dbConn
7722
7723 $reader = $cmd.ExecuteReader()
7724
7725 if ($reader.Read()) {
7726 $attr = $global:blankTaskHistoryAttrInt.PSObject.Copy()
7727
7728 $attr.ItemId = $historyId
7729 $attr.ItemId2 = $attributeId
7730 $attr.Owner = ConvertTo-PsType $reader[0]
7731 $attr.Value = ConvertTo-PsType $reader[1]
7732 $attr.Operation = ConvertTo-PsType $reader[2]
7733 }
7734 else {
7735 $attr = $null
7736 }
7737
7738 return $attr
7739 }
7740 catch {
7741 throw ("Error in Select-TaskHistoryAttrInt: " + $error[0])
7742 }
7743 finally {
7744 if ($reader) {$reader.Close()}
7745 }
7746} # Select-TaskHistoryAttrInt
7747
7748
7749Function Update-TaskHistoryAttrInt ($attr, $dbConn) {
7750 try {
7751 $cmd = New-Object System.Data.SqlClient.SqlCommand
7752
7753 $cmd.CommandText = "
7754 update TaskHistoryAttrInt
7755 set intvalue = @value, operation = @operation
7756 where historyid = @historyid
7757 and attributeid = @attributeid
7758 "
7759
7760 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7761 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7762
7763 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7764 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7765
7766 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Int) | Out-Null
7767 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
7768
7769 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7770 $cmd.Parameters["@operation"].Value = $attr.Operation
7771
7772 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7773 $cmd = (ConvertTo-OracleCommand $cmd)
7774 }
7775
7776 $cmd.Connection = $dbConn
7777
7778 $rowsAffected = $cmd.ExecuteNonQuery()
7779
7780 return $rowsAffected
7781 }
7782 catch {
7783 throw ("Error in Update-TaskHistoryAttrInt: " + $error[0])
7784 }
7785} # Update-TaskHistoryAttrInt
7786
7787
7788Function Insert-TaskHistoryAttrInt ($attr, $dbConn) {
7789 try {
7790 $cmd = New-Object System.Data.SqlClient.SqlCommand
7791
7792 $cmd.CommandText = "
7793 insert into TaskHistoryAttrInt (historyid, attributeid, intvalue, operation)
7794 values (@historyid, @attributeid, @value, @operation)
7795 "
7796
7797 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7798 $cmd.Parameters["@historyid"].Value = $attr.ItemId
7799
7800 $cmd.Parameters.Add("@attributeid", [System.Data.SqlDbType]::Int) | Out-Null
7801 $cmd.Parameters["@attributeid"].Value = $attr.ItemId2
7802
7803 $cmd.Parameters.Add("@value", [System.Data.SqlDbType]::Int) | Out-Null
7804 $cmd.Parameters["@value"].Value = (ConvertTo-DbNull $attr.Value)
7805
7806 $cmd.Parameters.Add("@operation", [System.Data.SqlDbType]::Int) | Out-Null
7807 $cmd.Parameters["@operation"].Value = $attr.Operation
7808
7809 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7810 $cmd = (ConvertTo-OracleCommand $cmd)
7811 }
7812
7813 $cmd.Connection = $dbConn
7814
7815 $rowsAffected = $cmd.ExecuteNonQuery()
7816
7817 return $rowsAffected
7818 }
7819 catch {
7820 throw ("Error in Insert-TaskHistoryAttrInt: " + $error[0])
7821 }
7822} # Insert-TaskHistoryAttrInt
7823
7824
7825$global:diffQueries["TaskHistoryAction_SatNotAtMaster"] = "
7826 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7827 select @satelliteid, 'TaskHistoryAction', tha_sat.historyid, tha_sat.seqorder, 'Unprocessed', @statustime
7828 from {SatellitePrefix}TaskHistoryAction{SatelliteSuffix} tha_sat
7829 where not exists (
7830 select 1
7831 from {MasterPrefix}TaskHistoryAction{MasterSuffix}
7832 where historyid = tha_sat.historyid
7833 and seqorder = tha_sat.seqorder
7834 )
7835"
7836
7837$global:diffQueries["TaskHistoryAction_MasterSatDiff"] = "
7838 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
7839 select @satelliteid, 'TaskHistoryAction', tha_mast.historyid, tha_mast.seqorder, 'Unprocessed', @statustime
7840 from {MasterPrefix}TaskHistoryAction{MasterSuffix} tha_mast
7841 join {MasterPrefix}TaskHistory{MasterSuffix} th_mast on th_mast.historyid = tha_mast.historyid
7842 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = th_mast.fileid
7843 join {SatellitePrefix}TaskHistoryAction{SatelliteSuffix} tha_sat on tha_sat.historyid = tha_mast.historyid and tha_sat.seqorder = tha_mast.seqorder
7844 join {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat on th_sat.historyid = tha_sat.historyid
7845 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = th_sat.fileid
7846 where (tha_mast.operationid <> tha_sat.operationid and not (tha_mast.operationid = 18 and tha_sat.operationid = 23))
7847 or tha_mast.accountid <> tha_sat.accountid
7848 or tha_mast.operationtime <> tha_sat.operationtime
7849 or tha_mast.operationtime is null and tha_sat.operationtime is not null
7850 or tha_mast.operationtime is not null and tha_sat.operationtime is null
7851 or tha_mast.locktime <> tha_sat.locktime
7852 or tha_mast.locktime is null and tha_sat.locktime is not null
7853 or tha_mast.locktime is not null and tha_sat.locktime is null
7854"
7855
7856
7857Function Merge-TaskHistoryAction ($action1, $action2) {
7858 try {
7859 $action1.OperationTime = Merge-Value $action1.OperationTime $action2.OperationTime "ReplaceNull" "Lesser"
7860 $action1.LockTime = Merge-Value $action1.LockTime $action2.LockTime "ReplaceNull" "Lesser"
7861
7862 if ($action1.OperationId -eq 23 -and $action2.OperationId -eq 18) {$action1.OperationId = 18}
7863
7864 return $action1
7865 }
7866 catch {
7867 throw ("Error in Merge-TaskHistoryAction: " + $error[0])
7868 }
7869} # Merge-TaskHistoryAction
7870
7871
7872# Create blank object once, so it can be copied to create new instances.
7873# This results in huge performance gains.
7874$global:blankTaskHistoryAction = $global:blankItem.PSObject.Copy()
7875$global:blankTaskHistoryAction.ItemType = "TaskHistoryAction"
7876$global:blankTaskHistoryAction | Add-Member NoteProperty OperationId $null
7877$global:blankTaskHistoryAction | Add-Member NoteProperty AccountId $null
7878$global:blankTaskHistoryAction | Add-Member NoteProperty OperationTime $null
7879$global:blankTaskHistoryAction | Add-Member NoteProperty LockTime $null
7880
7881Function Select-TaskHistoryAction ($historyId, $seqOrder, $dbConn) {
7882 try {
7883 $cmd = New-Object System.Data.SqlClient.SqlCommand
7884
7885 $cmd.CommandText = "
7886 select f.owner, tha.operationid, tha.accountid, tha.operationtime, tha.locktime
7887 from TaskHistoryAction tha
7888 join TaskHistory th on th.historyid = tha.historyid
7889 join Files f on f.fileid = th.fileid
7890 where tha.historyid = @historyid
7891 and tha.seqorder = @seqorder
7892 "
7893
7894 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7895 $cmd.Parameters["@historyid"].Value = $historyId
7896
7897 $cmd.Parameters.Add("@seqorder", [System.Data.SqlDbType]::Int) | Out-Null
7898 $cmd.Parameters["@seqorder"].Value = $seqOrder
7899
7900 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7901 $cmd = (ConvertTo-OracleCommand $cmd)
7902 }
7903
7904 $cmd.Connection = $dbConn
7905
7906 $reader = $cmd.ExecuteReader()
7907
7908 if ($reader.Read()) {
7909 $action = $global:blankTaskHistoryAction.PSObject.Copy()
7910
7911 $action.ItemId = $historyId
7912 $action.ItemId2 = $seqOrder
7913 $action.Owner = ConvertTo-PsType $reader[0]
7914 $action.OperationId = ConvertTo-PsType $reader[1]
7915 $action.AccountId = ConvertTo-PsType $reader[2]
7916 $action.OperationTime = ConvertTo-PsType $reader[3]
7917 $action.LockTime = ConvertTo-PsType $reader[4]
7918 }
7919 else {
7920 $action = $null
7921 }
7922
7923 return $action
7924 }
7925 catch {
7926 throw ("Error in Select-TaskHistoryAction: " + $error[0])
7927 }
7928 finally {
7929 if ($reader) {$reader.Close()}
7930 }
7931} # Select-TaskHistoryAction
7932
7933
7934Function Update-TaskHistoryAction ($action, $dbConn) {
7935 try {
7936 $cmd = New-Object System.Data.SqlClient.SqlCommand
7937
7938 $cmd.CommandText = "
7939 update TaskHistoryAction
7940 set operationid = @operationid, accountid = @accountid,
7941 operationtime = @operationtime, locktime = @locktime
7942 where historyid = @historyid
7943 and seqorder = @seqorder
7944 "
7945
7946 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7947 $cmd.Parameters["@historyid"].Value = $action.ItemId
7948
7949 $cmd.Parameters.Add("@seqorder", [System.Data.SqlDbType]::Int) | Out-Null
7950 $cmd.Parameters["@seqorder"].Value = $action.ItemId2
7951
7952 $cmd.Parameters.Add("@operationid", [System.Data.SqlDbType]::Int) | Out-Null
7953 $cmd.Parameters["@operationid"].Value = (ConvertTo-DbNull $action.OperationId)
7954
7955 $cmd.Parameters.Add("@accountid", [System.Data.SqlDbType]::Int) | Out-Null
7956 $cmd.Parameters["@accountid"].Value = $action.AccountId
7957
7958 $cmd.Parameters.Add("@operationtime", [System.Data.SqlDbType]::DateTime) | Out-Null
7959 $cmd.Parameters["@operationtime"].Value = (ConvertTo-DbNull $action.OperationTime)
7960
7961 $cmd.Parameters.Add("@locktime", [System.Data.SqlDbType]::DateTime) | Out-Null
7962 $cmd.Parameters["@locktime"].Value = (ConvertTo-DbNull $action.LockTime)
7963
7964 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
7965 $cmd = (ConvertTo-OracleCommand $cmd)
7966 }
7967
7968 $cmd.Connection = $dbConn
7969
7970 $rowsAffected = $cmd.ExecuteNonQuery()
7971
7972 return $rowsAffected
7973 }
7974 catch {
7975 throw ("Error in Update-TaskHistoryAction: " + $error[0])
7976 }
7977} # Update-TaskHistoryAction
7978
7979
7980Function Insert-TaskHistoryAction ($action, $dbConn) {
7981 try {
7982 $cmd = New-Object System.Data.SqlClient.SqlCommand
7983
7984 $cmd.CommandText = "
7985 insert into TaskHistoryAction (historyid, seqorder, operationid, accountid, operationtime, locktime)
7986 values (@historyid, @seqorder, @operationid, @accountid, @operationtime, @locktime)
7987 "
7988
7989 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
7990 $cmd.Parameters["@historyid"].Value = $action.ItemId
7991
7992 $cmd.Parameters.Add("@seqorder", [System.Data.SqlDbType]::Int) | Out-Null
7993 $cmd.Parameters["@seqorder"].Value = $action.ItemId2
7994
7995 $cmd.Parameters.Add("@operationid", [System.Data.SqlDbType]::Int) | Out-Null
7996 $cmd.Parameters["@operationid"].Value = (ConvertTo-DbNull $action.OperationId)
7997
7998 $cmd.Parameters.Add("@accountid", [System.Data.SqlDbType]::Int) | Out-Null
7999 $cmd.Parameters["@accountid"].Value = $action.AccountId
8000
8001 $cmd.Parameters.Add("@operationtime", [System.Data.SqlDbType]::DateTime) | Out-Null
8002 $cmd.Parameters["@operationtime"].Value = (ConvertTo-DbNull $action.OperationTime)
8003
8004 $cmd.Parameters.Add("@locktime", [System.Data.SqlDbType]::DateTime) | Out-Null
8005 $cmd.Parameters["@locktime"].Value = (ConvertTo-DbNull $action.LockTime)
8006
8007 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8008 $cmd = (ConvertTo-OracleCommand $cmd)
8009 }
8010
8011 $cmd.Connection = $dbConn
8012
8013 $rowsAffected = $cmd.ExecuteNonQuery()
8014
8015 return $rowsAffected
8016 }
8017 catch {
8018 throw ("Error in Insert-TaskHistoryAction: " + $error[0])
8019 }
8020} # Insert-TaskHistoryAction
8021
8022
8023$global:diffQueries["TaskHistoryRoute_SatNotAtMaster"] = "
8024 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8025 select @satelliteid, 'TaskHistoryRoute', thr_sat.historyid, thr_sat.seqorder, 'Unprocessed', @statustime
8026 from {SatellitePrefix}TaskHistoryRoute{SatelliteSuffix} thr_sat
8027 where not exists (
8028 select 1
8029 from {MasterPrefix}TaskHistoryRoute{MasterSuffix}
8030 where historyid = thr_sat.historyid
8031 and seqorder = thr_sat.seqorder
8032 )
8033"
8034
8035$global:diffQueries["TaskHistoryRoute_MasterSatDiff"] = "
8036 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8037 select @satelliteid, 'TaskHistoryRoute', thr_mast.historyid, thr_mast.seqorder, 'Unprocessed', @statustime
8038 from {MasterPrefix}TaskHistoryRoute{MasterSuffix} thr_mast
8039 join {MasterPrefix}TaskHistory{MasterSuffix} th_mast on th_mast.historyid = thr_mast.historyid
8040 join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = th_mast.fileid
8041 join {SatellitePrefix}TaskHistoryRoute{SatelliteSuffix} thr_sat on thr_sat.historyid = thr_mast.historyid and thr_sat.seqorder = thr_mast.seqorder
8042 join {SatellitePrefix}TaskHistory{SatelliteSuffix} th_sat on th_sat.historyid = thr_sat.historyid
8043 join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = th_sat.fileid
8044 where thr_mast.deststeprootid <> thr_sat.deststeprootid
8045 or thr_mast.destaccountid <> thr_sat.destaccountid
8046 or thr_mast.destaccountid is null and thr_sat.destaccountid is not null
8047 or thr_mast.destaccountid is not null and thr_sat.destaccountid is null
8048"
8049
8050
8051Function Merge-TaskHistoryRoute ($route1, $route2) {
8052 try {
8053 $route1.DestAccountId = Merge-Value $route1.DestAccountId $route2.DestAccountId "ReplaceNull"
8054
8055 return $route1
8056 }
8057 catch {
8058 throw ("Error in Merge-TaskHistoryRoute: " + $error[0])
8059 }
8060} # Merge-TaskHistoryRoute
8061
8062
8063# Create blank object once, so it can be copied to create new instances.
8064# This results in huge performance gains.
8065$global:blankTaskHistoryRoute = $global:blankItem.PSObject.Copy()
8066$global:blankTaskHistoryRoute.ItemType = "TaskHistoryRoute"
8067$global:blankTaskHistoryRoute | Add-Member NoteProperty DestStepRootId $null
8068$global:blankTaskHistoryRoute | Add-Member NoteProperty DestAccountId $null
8069
8070Function Select-TaskHistoryRoute ($historyId, $seqOrder, $dbConn) {
8071 try {
8072 $cmd = New-Object System.Data.SqlClient.SqlCommand
8073
8074 $cmd.CommandText = "
8075 select f.owner, thr.deststeprootid, thr.destaccountid
8076 from TaskHistoryRoute thr
8077 join TaskHistory th on th.historyid = thr.historyid
8078 join Files f on f.fileid = th.fileid
8079 where thr.historyid = @historyid
8080 and thr.seqorder = @seqorder
8081 "
8082
8083 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
8084 $cmd.Parameters["@historyid"].Value = $historyId
8085
8086 $cmd.Parameters.Add("@seqorder", [System.Data.SqlDbType]::Int) | Out-Null
8087 $cmd.Parameters["@seqorder"].Value = $seqOrder
8088
8089 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8090 $cmd = (ConvertTo-OracleCommand $cmd)
8091 }
8092
8093 $cmd.Connection = $dbConn
8094
8095 $reader = $cmd.ExecuteReader()
8096
8097 if ($reader.Read()) {
8098 $route = $global:blankTaskHistoryRoute.PSObject.Copy()
8099
8100 $route.ItemId = $historyId
8101 $route.ItemId2 = $seqOrder
8102 $route.Owner = ConvertTo-PsType $reader[0]
8103 $route.DestStepRootId = ConvertTo-PsType $reader[1]
8104 $route.DestAccountId = ConvertTo-PsType $reader[2]
8105 }
8106 else {
8107 $route = $null
8108 }
8109
8110 return $route
8111 }
8112 catch {
8113 throw ("Error in Select-TaskHistoryRoute: " + $error[0])
8114 }
8115 finally {
8116 if ($reader) {$reader.Close()}
8117 }
8118} # Select-TaskHistoryRoute
8119
8120
8121Function Update-TaskHistoryRoute ($route, $dbConn) {
8122 try {
8123 $cmd = New-Object System.Data.SqlClient.SqlCommand
8124
8125 $cmd.CommandText = "
8126 update TaskHistoryRoute
8127 set deststeprootid = @deststeprootid, destaccountid = @destaccountid
8128 where historyid = @historyid
8129 and seqorder = @seqorder
8130 "
8131
8132 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
8133 $cmd.Parameters["@historyid"].Value = $route.ItemId
8134
8135 $cmd.Parameters.Add("@seqorder", [System.Data.SqlDbType]::Int) | Out-Null
8136 $cmd.Parameters["@seqorder"].Value = $route.ItemId2
8137
8138 $cmd.Parameters.Add("@deststeprootid", [System.Data.SqlDbType]::Int) | Out-Null
8139 $cmd.Parameters["@deststeprootid"].Value = $route.DestStepRootId
8140
8141 $cmd.Parameters.Add("@destaccountid", [System.Data.SqlDbType]::Int) | Out-Null
8142 $cmd.Parameters["@destaccountid"].Value = (ConvertTo-DbNull $route.DestAccountId)
8143
8144 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8145 $cmd = (ConvertTo-OracleCommand $cmd)
8146 }
8147
8148 $cmd.Connection = $dbConn
8149
8150 $rowsAffected = $cmd.ExecuteNonQuery()
8151
8152 return $rowsAffected
8153 }
8154 catch {
8155 throw ("Error in Update-TaskHistoryRoute: " + $error[0])
8156 }
8157} # Update-TaskHistoryRoute
8158
8159
8160Function Insert-TaskHistoryRoute ($route, $dbConn) {
8161 try {
8162 $cmd = New-Object System.Data.SqlClient.SqlCommand
8163
8164 $cmd.CommandText = "
8165 insert into TaskHistoryRoute (historyid, seqorder, deststeprootid, destaccountid)
8166 values (@historyid, @seqorder, @deststeprootid, @destaccountid)
8167 "
8168
8169 $cmd.Parameters.Add("@historyid", [System.Data.SqlDbType]::Int) | Out-Null
8170 $cmd.Parameters["@historyid"].Value = $route.ItemId
8171
8172 $cmd.Parameters.Add("@seqorder", [System.Data.SqlDbType]::Int) | Out-Null
8173 $cmd.Parameters["@seqorder"].Value = $route.ItemId2
8174
8175 $cmd.Parameters.Add("@deststeprootid", [System.Data.SqlDbType]::Int) | Out-Null
8176 $cmd.Parameters["@deststeprootid"].Value = $route.DestStepRootId
8177
8178 $cmd.Parameters.Add("@destaccountid", [System.Data.SqlDbType]::Int) | Out-Null
8179 $cmd.Parameters["@destaccountid"].Value = (ConvertTo-DbNull $route.DestAccountId)
8180
8181 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8182 $cmd = (ConvertTo-OracleCommand $cmd)
8183 }
8184
8185 $cmd.Connection = $dbConn
8186
8187 $rowsAffected = $cmd.ExecuteNonQuery()
8188
8189 return $rowsAffected
8190 }
8191 catch {
8192 throw ("Error in Insert-TaskHistoryRoute: " + $error[0])
8193 }
8194} # Insert-TaskHistoryRoute
8195
8196
8197$global:diffQueries["ObjectNote_MasterNotAtSat"] = "
8198 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8199 select @satelliteid, 'ObjectNote', ont_mast.noteid, null, 'Unprocessed', @statustime
8200 from {MasterPrefix}ObjectNotes{MasterSuffix} ont_mast
8201 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = ont_mast.objectid
8202 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = ont_mast.objectid
8203 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
8204 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid)
8205 and not exists (
8206 select 1
8207 from {SatellitePrefix}ObjectNotes{SatelliteSuffix}
8208 where noteid = ont_mast.noteid
8209 )
8210"
8211
8212$global:diffQueries["ObjectNote_SatNotAtMaster"] = "
8213 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8214 select @satelliteid, 'ObjectNote', ont_sat.noteid, null, 'Unprocessed', @statustime
8215 from {SatellitePrefix}ObjectNotes{SatelliteSuffix} ont_sat
8216 where not exists (
8217 select 1
8218 from {MasterPrefix}ObjectNotes{MasterSuffix}
8219 where noteid = ont_sat.noteid
8220 )
8221"
8222
8223$global:diffQueries["ObjectNote_MasterSatDiff"] = "
8224 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8225 select @satelliteid, 'ObjectNote', ont_mast.noteid, null, 'Unprocessed', @statustime
8226 from {MasterPrefix}ObjectNotes{MasterSuffix} ont_mast
8227 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = ont_mast.objectid
8228 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = ont_mast.objectid
8229 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
8230 join {SatellitePrefix}ObjectNotes{SatelliteSuffix} ont_sat on ont_sat.noteid = ont_mast.noteid
8231 left join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = ont_sat.objectid
8232 left join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = ont_sat.objectid
8233 left join {SatellitePrefix}Files{SatelliteSuffix} fdf_sat on fdf_sat.fileid = df_sat.fileid
8234 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid or f_sat.owner = @satelliteid or fdf_sat.owner = @satelliteid)
8235 and (
8236 ont_mast.versionnum <> ont_sat.versionnum
8237 or ont_mast.objectid <> ont_sat.objectid
8238 or ont_mast.isdeleted <> ont_sat.isdeleted
8239 or ont_mast.notetypeid <> ont_sat.notetypeid
8240 or ont_mast.defaultnote <> ont_sat.defaultnote
8241 or ont_mast.defaultnote is null and ont_sat.defaultnote is not null
8242 or ont_mast.defaultnote is not null and ont_sat.defaultnote is null
8243 )
8244"
8245
8246
8247Function Merge-ObjectNote ($note1, $note2) {
8248 try {
8249 $note1.DefaultNote = Merge-Value $note1.DefaultNote $note2.DefaultNote "ReplaceNull"
8250
8251 return $note1
8252 }
8253 catch {
8254 throw ("Error in Merge-ObjectNote: " + $error[0])
8255 }
8256} # Merge-ObjectNote
8257
8258
8259# Create blank object once, so it can be copied to create new instances.
8260# This results in huge performance gains.
8261$global:blankObjectNote = $global:blankItem.PSObject.Copy()
8262$global:blankObjectNote.ItemType = "ObjectNote"
8263$global:blankObjectNote | Add-Member NoteProperty VersionNum $null
8264$global:blankObjectNote | Add-Member NoteProperty ObjectId $null
8265$global:blankObjectNote | Add-Member NoteProperty IsDeleted $null
8266$global:blankObjectNote | Add-Member NoteProperty NoteTypeId $null
8267$global:blankObjectNote | Add-Member NoteProperty DefaultNote $null
8268
8269Function Select-ObjectNote ($noteId, $dbConn) {
8270 try {
8271 $cmd = New-Object System.Data.SqlClient.SqlCommand
8272
8273 $cmd.CommandText = "
8274 select case when f.owner is null then fdf.owner else f.owner end owner,
8275 ont.versionnum, ont.objectid, ont.isdeleted, ont.notetypeid, ont.defaultnote
8276 from ObjectNotes ont
8277 left join Files f on f.fileid = ont.objectid
8278 left join DocFolder df on df.docfolderid = ont.objectid
8279 left join Files fdf on fdf.fileid = df.fileid
8280 where ont.noteid = @noteid
8281 "
8282
8283 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
8284 $cmd.Parameters["@noteid"].Value = $noteId
8285
8286 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8287 $cmd = (ConvertTo-OracleCommand $cmd)
8288 }
8289
8290 $cmd.Connection = $dbConn
8291
8292 $reader = $cmd.ExecuteReader()
8293
8294 if ($reader.Read()) {
8295 $note = $global:blankObjectNote.PSObject.Copy()
8296
8297 $note.ItemId = $noteId
8298 $note.ItemId2 = $null
8299 $note.Owner = ConvertTo-PsType $reader[0]
8300 $note.VersionNum = ConvertTo-PsType $reader[1]
8301 $note.ObjectId = ConvertTo-PsType $reader[2]
8302 $note.IsDeleted = ConvertTo-PsType $reader[3]
8303 $note.NoteTypeId = ConvertTo-PsType $reader[4]
8304 $note.DefaultNote = ConvertTo-PsType $reader[5]
8305 }
8306 else {
8307 $note = $null
8308 }
8309
8310 return $note
8311 }
8312 catch {
8313 throw ("Error in Select-ObjectNote: " + $error[0])
8314 }
8315 finally {
8316 if ($reader) {$reader.Close()}
8317 }
8318} # Select-ObjectNote
8319
8320
8321Function Update-ObjectNote ($note, $dbConn) {
8322 try {
8323 $cmd = New-Object System.Data.SqlClient.SqlCommand
8324
8325 $cmd.CommandText = "
8326 update ObjectNotes
8327 set versionnum = @versionnum, objectid = @objectid, isdeleted = @isdeleted,
8328 notetypeid = @notetypeid, defaultnote = @defaultnote
8329 where noteid = @noteid
8330 "
8331
8332 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
8333 $cmd.Parameters["@noteid"].Value = $note.ItemId
8334
8335 $cmd.Parameters.Add("@versionnum", [System.Data.SqlDbType]::Int) | Out-Null
8336 $cmd.Parameters["@versionnum"].Value = $note.VersionNum
8337
8338 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
8339 $cmd.Parameters["@objectid"].Value = $note.ObjectId
8340
8341 $cmd.Parameters.Add("@isdeleted", [System.Data.SqlDbType]::Int) | Out-Null
8342 $cmd.Parameters["@isdeleted"].Value = $note.IsDeleted
8343
8344 $cmd.Parameters.Add("@notetypeid", [System.Data.SqlDbType]::Int) | Out-Null
8345 $cmd.Parameters["@notetypeid"].Value = $note.NoteTypeId
8346
8347 $cmd.Parameters.Add("@defaultnote", [System.Data.SqlDbType]::Int) | Out-Null
8348 $cmd.Parameters["@defaultnote"].Value = ConvertTo-DbNull $note.DefaultNote
8349
8350 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8351 $cmd = (ConvertTo-OracleCommand $cmd)
8352 }
8353
8354 $cmd.Connection = $dbConn
8355
8356 $rowsAffected = $cmd.ExecuteNonQuery()
8357
8358 return $rowsAffected
8359 }
8360 catch {
8361 throw ("Error in Update-ObjectNote: " + $error[0])
8362 }
8363} # Update-ObjectNote
8364
8365
8366Function Insert-ObjectNote ($note, $dbConn) {
8367 try {
8368 $cmd = New-Object System.Data.SqlClient.SqlCommand
8369
8370 $cmd.CommandText = "
8371 insert into ObjectNotes (noteid, versionnum, objectid, isdeleted, notetypeid, defaultnote)
8372 values (@noteid, @versionnum, @objectid, @isdeleted, @notetypeid, @defaultnote)
8373 "
8374
8375 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
8376 $cmd.Parameters["@noteid"].Value = $note.ItemId
8377
8378 $cmd.Parameters.Add("@versionnum", [System.Data.SqlDbType]::Int) | Out-Null
8379 $cmd.Parameters["@versionnum"].Value = $note.VersionNum
8380
8381 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
8382 $cmd.Parameters["@objectid"].Value = $note.ObjectId
8383
8384 $cmd.Parameters.Add("@isdeleted", [System.Data.SqlDbType]::Int) | Out-Null
8385 $cmd.Parameters["@isdeleted"].Value = $note.IsDeleted
8386
8387 $cmd.Parameters.Add("@notetypeid", [System.Data.SqlDbType]::Int) | Out-Null
8388 $cmd.Parameters["@notetypeid"].Value = $note.NoteTypeId
8389
8390 $cmd.Parameters.Add("@defaultnote", [System.Data.SqlDbType]::Int) | Out-Null
8391 $cmd.Parameters["@defaultnote"].Value = ConvertTo-DbNull $note.DefaultNote
8392
8393 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8394 $cmd = (ConvertTo-OracleCommand $cmd)
8395 }
8396
8397 $cmd.Connection = $dbConn
8398
8399 $rowsAffected = $cmd.ExecuteNonQuery()
8400
8401 return $rowsAffected
8402 }
8403 catch {
8404 throw ("Error in Insert-ObjectNote: " + $error[0])
8405 }
8406} # Insert-ObjectNote
8407
8408
8409$global:diffQueries["ObjectNoteDetail_MasterNotAtSat"] = "
8410 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8411 select @satelliteid, 'ObjectNoteDetail', ond_mast.noteid, ond_mast.imagesetid, 'Unprocessed', @statustime
8412 from {MasterPrefix}ObjectNotesDetail{MasterSuffix} ond_mast
8413 join {MasterPrefix}ObjectNotes{MasterSuffix} ont_mast on ont_mast.noteid = ond_mast.noteid
8414 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = ont_mast.objectid
8415 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = ont_mast.objectid
8416 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
8417 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid)
8418 and not exists (
8419 select 1
8420 from {SatellitePrefix}ObjectNotesDetail{SatelliteSuffix}
8421 where noteid = ond_mast.noteid
8422 and imagesetid = ond_mast.imagesetid
8423 )
8424"
8425
8426$global:diffQueries["ObjectNoteDetail_SatNotAtMaster"] = "
8427 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8428 select @satelliteid, 'ObjectNoteDetail', ond_sat.noteid, ond_sat.imagesetid, 'Unprocessed', @statustime
8429 from {SatellitePrefix}ObjectNotesDetail{SatelliteSuffix} ond_sat
8430 where not exists (
8431 select 1
8432 from {MasterPrefix}ObjectNotesDetail{MasterSuffix}
8433 where noteid = ond_sat.noteid
8434 and imagesetid = ond_sat.imagesetid
8435 )
8436"
8437
8438$global:diffQueries["ObjectNoteDetail_MasterSatDiff"] = "
8439 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8440 select @satelliteid, 'ObjectNoteDetail', ond_mast.noteid, ond_mast.imagesetid, 'Unprocessed', @statustime
8441 from {MasterPrefix}ObjectNotesDetail{MasterSuffix} ond_mast
8442 join {MasterPrefix}ObjectNotes{MasterSuffix} ont_mast on ont_mast.noteid = ond_mast.noteid
8443 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = ont_mast.objectid
8444 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = ont_mast.objectid
8445 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
8446 join {SatellitePrefix}ObjectNotesDetail{SatelliteSuffix} ond_sat on ond_sat.noteid = ond_mast.noteid and ond_sat.imagesetid = ond_mast.imagesetid
8447 join {SatellitePrefix}ObjectNotes{SatelliteSuffix} ont_sat on ont_sat.noteid = ond_sat.noteid
8448 left join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = ont_sat.objectid
8449 left join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = ont_sat.objectid
8450 left join {SatellitePrefix}Files{SatelliteSuffix} fdf_sat on fdf_sat.fileid = df_sat.fileid
8451 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid or f_sat.owner = @satelliteid or fdf_sat.owner = @satelliteid)
8452 and ond_mast.hidden <> ond_sat.hidden
8453"
8454
8455
8456Function Merge-ObjectNoteDetail ($note1, $note2) {
8457 try {
8458 return $note1
8459 }
8460 catch {
8461 throw ("Error in Merge-ObjectNoteDetail: " + $error[0])
8462 }
8463} # Merge-ObjectNoteDetail
8464
8465
8466# Create blank object once, so it can be copied to create new instances.
8467# This results in huge performance gains.
8468$global:blankObjectNoteDetail = $global:blankItem.PSObject.Copy()
8469$global:blankObjectNoteDetail.ItemType = "ObjectNoteDetail"
8470$global:blankObjectNoteDetail | Add-Member NoteProperty Hidden $null
8471
8472Function Select-ObjectNoteDetail ($noteId, $imageSetId, $dbConn) {
8473 try {
8474 $cmd = New-Object System.Data.SqlClient.SqlCommand
8475
8476 $cmd.CommandText = "
8477 select case when f.owner is null then fdf.owner else f.owner end owner, ond.hidden
8478 from ObjectNotesDetail ond
8479 join ObjectNotes ont on ont.noteid = ond.noteid
8480 left join Files f on f.fileid = ont.objectid
8481 left join DocFolder df on df.docfolderid = ont.objectid
8482 left join Files fdf on fdf.fileid = df.fileid
8483 where ond.noteid = @noteid
8484 and ond.imagesetid = @imagesetid
8485 "
8486
8487 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
8488 $cmd.Parameters["@noteid"].Value = $noteId
8489
8490 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
8491 $cmd.Parameters["@imagesetid"].Value = $imageSetId
8492
8493 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8494 $cmd = (ConvertTo-OracleCommand $cmd)
8495 }
8496
8497 $cmd.Connection = $dbConn
8498
8499 $reader = $cmd.ExecuteReader()
8500
8501 if ($reader.Read()) {
8502 $detail = $global:blankObjectNoteDetail.PSObject.Copy()
8503
8504 $detail.ItemId = $noteId
8505 $detail.ItemId2 = $imageSetId
8506 $detail.Owner = ConvertTo-PsType $reader[0]
8507 $detail.Hidden = ConvertTo-PsType $reader[1]
8508 }
8509 else {
8510 $detail = $null
8511 }
8512
8513 return $detail
8514 }
8515 catch {
8516 throw ("Error in Select-ObjectNoteDetail: " + $error[0])
8517 }
8518 finally {
8519 if ($reader) {$reader.Close()}
8520 }
8521} # Select-ObjectNoteDetail
8522
8523
8524Function Update-ObjectNoteDetail ($detail, $dbConn) {
8525 try {
8526 $cmd = New-Object System.Data.SqlClient.SqlCommand
8527
8528 $cmd.CommandText = "
8529 update ObjectNotesDetail
8530 set hidden = @hidden
8531 where noteid = @noteid
8532 and imagesetid = @imagesetid
8533 "
8534
8535 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
8536 $cmd.Parameters["@noteid"].Value = $detail.ItemId
8537
8538 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
8539 $cmd.Parameters["@imagesetid"].Value = $detail.ItemId2
8540
8541 $cmd.Parameters.Add("@hidden", [System.Data.SqlDbType]::Int) | Out-Null
8542 $cmd.Parameters["@hidden"].Value = $detail.Hidden
8543
8544 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8545 $cmd = (ConvertTo-OracleCommand $cmd)
8546 }
8547
8548 $cmd.Connection = $dbConn
8549
8550 $rowsAffected = $cmd.ExecuteNonQuery()
8551
8552 return $rowsAffected
8553 }
8554 catch {
8555 throw ("Error in Update-ObjectNoteDetail: " + $error[0])
8556 }
8557} # Update-ObjectNoteDetail
8558
8559
8560Function Insert-ObjectNoteDetail ($detail, $dbConn) {
8561 try {
8562 $cmd = New-Object System.Data.SqlClient.SqlCommand
8563
8564 $cmd.CommandText = "
8565 insert into ObjectNotesDetail (noteid, imagesetid, hidden)
8566 values (@noteid, @imagesetid, @hidden)
8567 "
8568
8569 $cmd.Parameters.Add("@noteid", [System.Data.SqlDbType]::Int) | Out-Null
8570 $cmd.Parameters["@noteid"].Value = $detail.ItemId
8571
8572 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
8573 $cmd.Parameters["@imagesetid"].Value = $detail.ItemId2
8574
8575 $cmd.Parameters.Add("@hidden", [System.Data.SqlDbType]::Int) | Out-Null
8576 $cmd.Parameters["@hidden"].Value = $detail.Hidden
8577
8578 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
8579 $cmd = (ConvertTo-OracleCommand $cmd)
8580 }
8581
8582 $cmd.Connection = $dbConn
8583
8584 $rowsAffected = $cmd.ExecuteNonQuery()
8585
8586 return $rowsAffected
8587 }
8588 catch {
8589 throw ("Error in Insert-ObjectNoteDetail: " + $error[0])
8590 }
8591} # Insert-ObjectNoteDetail
8592
8593
8594$global:diffQueries["ImageSet_MasterNotAtSat"] = "
8595 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8596 select @satelliteid, 'ImageSet', ist_mast.imagesetid, null, 'Unprocessed', @statustime
8597 from {MasterPrefix}ImageSet{MasterSuffix} ist_mast
8598 where ist_mast.owner = @satelliteid
8599 and not exists (
8600 select 1
8601 from {SatellitePrefix}ImageSet{SatelliteSuffix}
8602 where imagesetid = ist_mast.imagesetid
8603 )
8604 and not exists (
8605 select 1
8606 from SyncIssue
8607 where siteid = @satelliteid
8608 and type = 'ImageSet'
8609 and itemid = ist_mast.imagesetid
8610 )
8611"
8612
8613$global:diffQueries["ImageSet_SatNotAtMaster"] = "
8614 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8615 select @satelliteid, 'ImageSet', ist_sat.imagesetid, null, 'Unprocessed', @statustime
8616 from {SatellitePrefix}ImageSet{SatelliteSuffix} ist_sat
8617 where not exists (
8618 select 1
8619 from {MasterPrefix}ImageSet{MasterSuffix}
8620 where imagesetid = ist_sat.imagesetid
8621 )
8622 and not exists (
8623 select 1
8624 from SyncIssue
8625 where siteid = @satelliteid
8626 and type = 'ImageSet'
8627 and itemid = ist_sat.imagesetid
8628 )
8629"
8630
8631$global:diffQueries["ImageSet_MasterSatDiff"] = "
8632 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8633 select @satelliteid, 'ImageSet', ist_mast.imagesetid, null, 'Unprocessed', @statustime
8634 from {MasterPrefix}ImageSet{MasterSuffix} ist_mast
8635 join {SatellitePrefix}ImageSet{SatelliteSuffix} ist_sat on ist_sat.imagesetid = ist_mast.imagesetid
8636 where (ist_mast.owner = @satelliteid or ist_sat.owner = @satelliteid)
8637 and (
8638 ist_mast.encryptionkey <> ist_sat.encryptionkey
8639 or ist_mast.encryptionkey is null and ist_sat.encryptionkey is not null
8640 or ist_mast.encryptionkey is not null and ist_sat.encryptionkey is null
8641 or ist_mast.currentversion <> ist_sat.currentversion
8642 or ist_mast.owner <> ist_sat.owner
8643 or ist_mast.owner is null and ist_sat.owner is not null
8644 or ist_mast.owner is not null and ist_sat.owner is null
8645 or ist_mast.batchid <> ist_sat.batchid
8646 or ist_mast.batchid is null and ist_sat.batchid is not null
8647 --or ist_mast.batchid is not null and ist_sat.batchid is null
8648 )
8649 and not exists (
8650 select 1
8651 from SyncIssue
8652 where siteid = @satelliteid
8653 and type = 'ImageSet'
8654 and itemid = ist_mast.imagesetid
8655 )
8656"
8657
8658$global:diffQueries["ImageSet_MasterIncomplete"] = "
8659 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8660 select @satelliteid, 'ImageSet', ist_mast.imagesetid, null, 'Unprocessed', @statustime
8661 from {MasterPrefix}ImageSet{MasterSuffix} ist_mast
8662 where not exists (
8663 select 1
8664 from {MasterPrefix}ImageSetVersions{MasterSuffix}
8665 where imagesetid = ist_mast.imagesetid
8666 )
8667 and not exists (
8668 select 1
8669 from SyncIssue
8670 where siteid = @satelliteid
8671 and type = 'ImageSet'
8672 and itemid = ist_mast.imagesetid
8673 )
8674"
8675
8676$global:diffQueries["ImageSet_SatIncomplete"] = "
8677 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8678 select @satelliteid, 'ImageSet', ist_sat.imagesetid, null, 'Unprocessed', @statustime
8679 from {SatellitePrefix}ImageSet{SatelliteSuffix} ist_sat
8680 where not exists (
8681 select 1
8682 from {SatellitePrefix}ImageSetVersions{SatelliteSuffix}
8683 where imagesetid = ist_sat.imagesetid
8684 )
8685 and not exists (
8686 select 1
8687 from SyncIssue
8688 where siteid = @satelliteid
8689 and type = 'ImageSet'
8690 and itemid = ist_sat.imagesetid
8691 )
8692"
8693
8694$global:diffQueries["ImageSetVersion_MasterNotAtSat"] = "
8695 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8696 select distinct @satelliteid, 'ImageSet', isv_mast.imagesetid, null, 'Unprocessed', @statustime
8697 from {MasterPrefix}ImageSetVersions{MasterSuffix} isv_mast
8698 join {MasterPrefix}ImageSet{MasterSuffix} ist_mast on ist_mast.imagesetid = isv_mast.imagesetid
8699 where ist_mast.owner = @satelliteid
8700 and not exists (
8701 select 1
8702 from {SatellitePrefix}ImageSetVersions{SatelliteSuffix}
8703 where imagesetid = isv_mast.imagesetid
8704 and imagesetversion = isv_mast.imagesetversion
8705 )
8706 and not exists (
8707 select 1
8708 from SyncIssue
8709 where siteid = @satelliteid
8710 and type = 'ImageSet'
8711 and itemid = isv_mast.imagesetid
8712 )
8713"
8714
8715$global:diffQueries["ImageSetVersion_SatNotAtMaster"] = "
8716 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8717 select distinct @satelliteid, 'ImageSet', isv_sat.imagesetid, null, 'Unprocessed', @statustime
8718 from {SatellitePrefix}ImageSetVersions{SatelliteSuffix} isv_sat
8719 where not exists (
8720 select 1
8721 from {MasterPrefix}ImageSetVersions{MasterSuffix}
8722 where imagesetid = isv_sat.imagesetid
8723 and imagesetversion = isv_sat.imagesetversion
8724 )
8725 and not exists (
8726 select 1
8727 from SyncIssue
8728 where siteid = @satelliteid
8729 and type = 'ImageSet'
8730 and itemid = isv_sat.imagesetid
8731 )
8732"
8733
8734$global:diffQueries["ImageSetVersion_MasterSatDiff"] = "
8735 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8736 select distinct @satelliteid, 'ImageSet', isv_mast.imagesetid, null, 'Unprocessed', @statustime
8737 from {MasterPrefix}ImageSetVersions{MasterSuffix} isv_mast
8738 join {SatellitePrefix}ImageSetVersions{SatelliteSuffix} isv_sat on isv_sat.imagesetid = isv_mast.imagesetid and isv_sat.imagesetversion = isv_mast.imagesetversion
8739 where (
8740 isv_mast.accountid <> isv_sat.accountid
8741 or isv_mast.datechanged <> isv_sat.datechanged
8742 )
8743 and not exists (
8744 select 1
8745 from SyncIssue
8746 where siteid = @satelliteid
8747 and type = 'ImageSet'
8748 and itemid = isv_mast.imagesetid
8749 )
8750"
8751
8752$global:diffQueries["ImageSetVersionData_MasterNotAtSat"] = "
8753 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8754 select distinct @satelliteid, 'ImageSet', isvd_mast.imagesetid, null, 'Unprocessed', @statustime
8755 from {MasterPrefix}ImageSetVersionData{MasterSuffix} isvd_mast
8756 join {MasterPrefix}ImageSet{MasterSuffix} ist_mast on ist_mast.imagesetid = isvd_mast.imagesetid
8757 where ist_mast.owner = @satelliteid
8758 and not exists (
8759 select 1
8760 from {SatellitePrefix}ImageSetVersionData{SatelliteSuffix}
8761 where imagesetid = isvd_mast.imagesetid
8762 and imagesetversion = isvd_mast.imagesetversion
8763 and imageid = isvd_mast.imageid
8764 and imageversion = isvd_mast.imageversion
8765 )
8766 and not exists (
8767 select 1
8768 from SyncIssue
8769 where siteid = @satelliteid
8770 and type = 'ImageSet'
8771 and itemid = isvd_mast.imagesetid
8772 )
8773"
8774
8775$global:diffQueries["ImageSetVersionData_SatNotAtMaster"] = "
8776 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8777 select distinct @satelliteid, 'ImageSet', isvd_sat.imagesetid, null, 'Unprocessed', @statustime
8778 from {SatellitePrefix}ImageSetVersionData{SatelliteSuffix} isvd_sat
8779 where not exists (
8780 select 1
8781 from {MasterPrefix}ImageSetVersionData{MasterSuffix}
8782 where imagesetid = isvd_sat.imagesetid
8783 and imagesetversion = isvd_sat.imagesetversion
8784 and imageid = isvd_sat.imageid
8785 and imageversion = isvd_sat.imageversion
8786 )
8787 and not exists (
8788 select 1
8789 from SyncIssue
8790 where siteid = @satelliteid
8791 and type = 'ImageSet'
8792 and itemid = isvd_sat.imagesetid
8793 )
8794"
8795
8796$global:diffQueries["ImageSetVersionData_MasterSatDiff"] = "
8797 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8798 select distinct @satelliteid, 'ImageSet', isvd_mast.imagesetid, null, 'Unprocessed', @statustime
8799 from {MasterPrefix}ImageSetVersionData{MasterSuffix} isvd_mast
8800 join {SatellitePrefix}ImageSetVersionData{SatelliteSuffix} isvd_sat on isvd_sat.imagesetid = isvd_mast.imagesetid and isvd_sat.imagesetversion = isvd_mast.imagesetversion and isvd_sat.imageid = isvd_mast.imageid and isvd_sat.imageversion = isvd_mast.imageversion
8801 where isvd_mast.islinked <> isvd_sat.islinked
8802 and not exists (
8803 select 1
8804 from SyncIssue
8805 where siteid = @satelliteid
8806 and type = 'ImageSet'
8807 and itemid = isvd_mast.imagesetid
8808 )
8809"
8810
8811$global:diffQueries["ImageSetVersionData_MultipleNotLinked"] = "
8812 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8813 select distinct @satelliteid, 'ImageSet', isvd_mast.imagesetid, null, 'Unprocessed', @statustime
8814 from {MasterPrefix}ImageSetVersionData{MasterSuffix} isvd_mast
8815 join {MasterPrefix}ImageSetVersionData{MasterSuffix} isvd_mast2 on isvd_mast2.imageid = isvd_mast.imageid
8816 where isvd_mast.islinked = 0
8817 and isvd_mast2.islinked = 0
8818 and isvd_mast.imagesetid <> isvd_mast2.imagesetid
8819 and not exists (
8820 select 1
8821 from SyncIssue
8822 where siteid = @satelliteid
8823 and type = 'ImageSet'
8824 and itemid = isvd_mast.imagesetid
8825 )
8826"
8827
8828$global:diffQueries["ImageVersion_MasterSatDiff"] = "
8829 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8830 select distinct @satelliteid, 'ImageSet', isvd_mast.imagesetid, null, 'Unprocessed', @statustime
8831 from {MasterPrefix}ImageVersion{MasterSuffix} iv_mast
8832 join {MasterPrefix}ImageSetVersionData{MasterSuffix} isvd_mast on isvd_mast.imageid = iv_mast.imageid and isvd_mast.imageversion = iv_mast.imageversion
8833 join {SatellitePrefix}ImageVersion{SatelliteSuffix} iv_sat on iv_sat.imageid = iv_mast.imageid and iv_sat.imageversion = iv_mast.imageversion
8834 join {SatellitePrefix}ImageSetVersionData{SatelliteSuffix} isvd_sat on isvd_sat.imageid = iv_sat.imageid and isvd_sat.imageversion = iv_sat.imageversion
8835 left join {SatellitePrefix}Device{SatelliteSuffix} d_sat on d_sat.deviceid = iv_sat.nearlinedevice
8836 where not (iv_mast.onlinedevice is null and iv_mast.nearlinedevice is null and d_sat.devicetype = 2)
8837 and (
8838 iv_mast.siteid is null and iv_sat.siteid is not null
8839 or iv_mast.siteid is not null and iv_sat.siteid is null
8840 or iv_mast.filesize <> iv_sat.filesize
8841 or iv_mast.rotation <> iv_sat.rotation
8842 or iv_mast.prerotation <> iv_sat.prerotation
8843 or iv_mast.contenttype <> iv_sat.contenttype and not (iv_mast.contenttype = 0 and iv_sat.contenttype <> 0)
8844 or iv_mast.status <> iv_sat.status
8845 or iv_mast.md5a <> iv_sat.md5a
8846 or iv_mast.md5a is null and iv_sat.md5a is not null
8847 or iv_mast.md5a is not null and iv_sat.md5a is null
8848 or iv_mast.md5b <> iv_sat.md5b
8849 or iv_mast.md5b is null and iv_sat.md5b is not null
8850 or iv_mast.md5b is not null and iv_sat.md5b is null
8851 )
8852 and not exists (
8853 select 1
8854 from SyncIssue
8855 where siteid = @satelliteid
8856 and type = 'ImageSet'
8857 and itemid = isvd_mast.imagesetid
8858 )
8859"
8860
8861$global:diffQueries["ImageVersion_SatelliteTracer"] = "
8862 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8863 select distinct @satelliteid, 'ImageSet', isvd_sat.imagesetid, null, 'Unprocessed', @statustime
8864 from {SatellitePrefix}TracerImageLog{SatelliteSuffix} til_sat
8865 join {SatellitePrefix}ImageSetVersionData{SatelliteSuffix} isvd_sat on isvd_sat.imageid = til_sat.imageid and isvd_sat.imageversion = til_sat.imageversion
8866 where not exists (
8867 select 1
8868 from SyncIssue
8869 where siteid = @satelliteid
8870 and type = 'ImageSet'
8871 and itemid = isvd_sat.imagesetid
8872 )
8873"
8874
8875$global:diffQueries["Image_MasterSatDiff"] = "
8876 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8877 select distinct @satelliteid, 'ImageSet', isvd_mast.imagesetid, null, 'Unprocessed', @statustime
8878 from {MasterPrefix}Image{MasterSuffix} i_mast
8879 join {MasterPrefix}ImageSetVersionData{MasterSuffix} isvd_mast on isvd_mast.imageid = i_mast.imageid
8880 join {SatellitePrefix}Image{SatelliteSuffix} i_sat on i_sat.imageid = i_mast.imageid
8881 join {SatellitePrefix}ImageSetVersionData{SatelliteSuffix} isvd_sat on isvd_sat.imageid = i_sat.imageid
8882 where (
8883 i_mast.currentversion <> i_sat.currentversion
8884 or i_mast.dynamicversion <> i_sat.dynamicversion
8885 or i_mast.dynamicversion is null and i_sat.dynamicversion is not null
8886 or i_mast.dynamicversion is not null and i_sat.dynamicversion is null
8887 or i_mast.ext <> i_sat.ext
8888 or i_mast.ext is null and i_sat.ext is not null
8889 or i_mast.ext is not null and i_sat.ext is null
8890 or i_mast.type <> i_sat.type
8891 or i_mast.type is null and i_sat.type is not null
8892 or i_mast.type is not null and i_sat.type is null
8893 )
8894 and not exists (
8895 select 1
8896 from SyncIssue
8897 where siteid = @satelliteid
8898 and type = 'ImageSet'
8899 and itemid = isvd_mast.imagesetid
8900 )
8901"
8902
8903$global:diffQueries["ImageVersion_SatelliteTracerOrphan"] = "
8904 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
8905 select distinct @satelliteid, 'ImageTraceOrphan', til_sat.imageid, til_sat.imageversion, 'Unprocessed', @statustime
8906 from {SatellitePrefix}TracerImageLog{SatelliteSuffix} til_sat
8907 where not exists (
8908 select 1
8909 from {SatellitePrefix}ImageSetVersionData{SatelliteSuffix}
8910 where imageid = til_sat.imageid
8911 and imageversion = til_sat.imageversion
8912 )
8913 and not exists (
8914 select 1
8915 from {MasterPrefix}ImageSetVersionData{MasterSuffix}
8916 where imageid = til_sat.imageid
8917 and imageversion = til_sat.imageversion
8918 )
8919"
8920
8921
8922# Each site that has any information about the imageset is added to the $relevantSites
8923# hash table at the script scope. We will need to save the synchronized imageset
8924# back to these sites.
8925Function Get-MergedImageSet ($imageSetId, $sites) {
8926 try {
8927 $siteQueue = New-Object System.Collections.Queue
8928 $imageSet = $null
8929
8930 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
8931
8932 while ($siteQueue.Count -gt 0 -and $imageSet -eq $null) {
8933 $site = $siteQueue.Dequeue()
8934 $imageSet = Get-ImageSet $imageSetId $site
8935 }
8936
8937 if ($imageSet -eq $null) {throw "ImageSet $imageSetId not found at any site."}
8938
8939 if ($site.SiteId -ne 0) {$script:relevantSites[$site.SiteId] = $site}
8940
8941 while ($siteQueue.Count -gt 0) {
8942 $site = $siteQueue.Dequeue()
8943
8944 $imageSetB = $null
8945 $imageSetB = Get-ImageSet $imageSetId $site
8946
8947 if ($imageSetB -ne $null) {
8948 $imageSet = Merge-ImageSet $imageSet $imageSetB
8949
8950 $script:relevantSites[$site.SiteId] = $site
8951 }
8952 }
8953
8954 return $imageSet
8955 }
8956 catch {
8957 throw ("Error in Get-MergedImageSet: " + $error[0])
8958 }
8959} # Get-MergedImageSet
8960
8961
8962Function Get-ImageSet ($imageSetId, $site) {
8963 try {
8964 $imageSet = Select-ImageSet $imageSetId $site.DbConn
8965
8966 if ($imageSet -ne $null) {
8967 $imageSet.Versions = Get-IsvTable $imageSetId $site
8968
8969 $imageSet.SiteId = $site.SiteId
8970 }
8971
8972 return $imageSet
8973 }
8974 catch {
8975 throw ("Error in Get-ImageSet: " + $error[0])
8976 }
8977} # Get-ImageSet
8978
8979
8980# Create blank object once, so it can be copied to create new instances.
8981# This results in huge performance gains.
8982$global:blankImageSet = New-Object PSObject
8983$global:blankImageSet | Add-Member NoteProperty ImageSetId $null
8984$global:blankImageSet | Add-Member NoteProperty EncryptionKey $null
8985$global:blankImageSet | Add-Member NoteProperty CurrentVersion $null
8986$global:blankImageSet | Add-Member NoteProperty Owner $null
8987$global:blankImageSet | Add-Member NoteProperty LockedBy $null
8988$global:blankImageSet | Add-Member NoteProperty LockExpiration $null
8989$global:blankImageSet | Add-Member NoteProperty DynamicVersion $null
8990$global:blankImageSet | Add-Member NoteProperty BatchId $null
8991$global:blankImageSet | Add-Member NoteProperty LockDetails $null
8992$global:blankImageSet | Add-Member NoteProperty Versions $null
8993$global:blankImageSet | Add-Member NoteProperty Batch $null
8994$global:blankImageSet | Add-Member NoteProperty SiteId $null
8995
8996Function Select-ImageSet ($imageSetId, $dbConn) {
8997 try {
8998 $cmd = New-Object System.Data.SqlClient.SqlCommand
8999
9000 $cmd.CommandText = "
9001 select encryptionkey, currentversion, owner, lockedby, lockexpiration, dynamicversion,
9002 batchid, lockdetails
9003 from ImageSet
9004 where imagesetid = @imagesetid
9005 "
9006
9007 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
9008 $cmd.Parameters["@imagesetid"].Value = $imageSetId
9009
9010 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
9011 $cmd = (ConvertTo-OracleCommand $cmd)
9012 }
9013
9014 $cmd.Connection = $dbConn
9015
9016 $reader = $cmd.ExecuteReader()
9017
9018 if ($reader.Read()) {
9019 $imageSet = $global:blankImageSet.PSObject.Copy()
9020
9021 $imageSet.ImageSetId = $imageSetId
9022 $imageSet.EncryptionKey = ConvertTo-PsType $reader[0]
9023 $imageSet.CurrentVersion = ConvertTo-PsType $reader[1]
9024 $imageSet.Owner = ConvertTo-PsType $reader[2]
9025 $imageSet.LockedBy = ConvertTo-PsType $reader[3]
9026 $imageSet.LockExpiration = ConvertTo-PsType $reader[4]
9027 $imageSet.DynamicVersion = ConvertTo-PsType $reader[5]
9028 $imageSet.BatchId = ConvertTo-PsType $reader[6]
9029 $imageSet.LockDetails = ConvertTo-PsType $reader[7]
9030 $imageSet.Versions = $null
9031 $imageSet.Batch = $null
9032 }
9033 else {
9034 $imageSet = $null
9035 }
9036
9037 return $imageSet
9038 }
9039 catch {
9040 throw ("Error in Select-ImageSet: " + $error[0])
9041 }
9042 finally {
9043 if ($reader) {$reader.Close()}
9044 }
9045} # Select-ImageSet
9046
9047
9048Function Get-IsvTable ($imageSetId, $site) {
9049 try {
9050 $isvTable = Select-ImageSetVersions $imageSetId $site.DbConn
9051 $cacheOk = $true
9052
9053 $isvTable.Values | ForEach-Object {
9054 $_.Image = Get-Image $_.ImageSetId $_.Version "Image" $site $cacheOk
9055 $_.Annotation = Get-Image $_.ImageSetId $_.Version "Annotation" $site $cacheOk
9056 }
9057
9058 return $isvTable
9059 }
9060 catch {
9061 throw ("Error in Get-IsvTable: " + $error[0])
9062 }
9063} # Get-IsvTable
9064
9065
9066# Create blank object once, so it can be copied to create new instances.
9067# This results in huge performance gains.
9068$global:blankIsv = New-Object PSObject
9069$global:blankIsv | Add-Member NoteProperty ImageSetId $null
9070$global:blankIsv | Add-Member NoteProperty Version $null
9071$global:blankIsv | Add-Member NoteProperty AccountId $null
9072$global:blankIsv | Add-Member NoteProperty DateChanged $null
9073$global:blankIsv | Add-Member NoteProperty Image $null
9074$global:blankIsv | Add-Member NoteProperty Annotation $null
9075
9076# ImageSetVersions without ImageSetVersionData records are pretty meaningless for our purpose,
9077# since they're not linked to any images. As such, we ignore them.
9078Function Select-ImageSetVersions ($imageSetId, $dbConn) {
9079 try {
9080 $cmd = New-Object System.Data.SqlClient.SqlCommand
9081
9082 $cmd.CommandText = "
9083 select isv.imagesetversion, isv.accountid, isv.datechanged
9084 from ImageSetVersions isv
9085 where isv.imagesetid = @imagesetid
9086 and exists (
9087 select 1
9088 from ImageSetVersionData
9089 where imagesetid = isv.imagesetid
9090 and imagesetversion = isv.imagesetversion
9091 )
9092 "
9093
9094 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
9095 $cmd.Parameters["@imagesetid"].Value = $imageSetId
9096
9097 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
9098 $cmd = (ConvertTo-OracleCommand $cmd)
9099 }
9100
9101 $cmd.Connection = $dbConn
9102
9103 $reader = $cmd.ExecuteReader()
9104
9105 $isvTable = @{}
9106
9107 while ($reader.Read()) {
9108 $isv = $global:blankIsv.PSObject.Copy()
9109
9110 $isv.ImageSetId = $imageSetId
9111 $isv.Version = ConvertTo-PsType $reader[0]
9112 $isv.AccountId = ConvertTo-PsType $reader[1]
9113 $isv.DateChanged = ConvertTo-PsType $reader[2]
9114 $isv.Image = $null
9115 $isv.Annotation = $null
9116
9117 $isvTable.Add($isv.Version, $isv)
9118 }
9119
9120 return $isvTable
9121 }
9122 catch {
9123 throw ("Error in Select-ImageSetVersions: " + $error[0])
9124 }
9125 finally {
9126 if ($reader) {$reader.Close()}
9127 }
9128} # Select-ImageSetVersions
9129
9130
9131Function Get-MergedImage ($imageId, $imageVersion, $sites) {
9132 try {
9133 $siteQueue = New-Object System.Collections.Queue
9134
9135 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
9136
9137 $image = $null
9138 $cacheOk = $true
9139
9140 while ($image -eq $null -and $siteQueue.Count -gt 0) {
9141 $site = $siteQueue.Dequeue()
9142 $image = Get-Image $imageId $imageVersion $null $site $cacheOk
9143 }
9144
9145 if ($image -eq $null) {return $null}
9146
9147 if ($site.SiteId -ne 0) {$script:relevantSites[$site.SiteId] = $site}
9148
9149 while ($siteQueue.Count -gt 0) {
9150 $site = $siteQueue.Dequeue()
9151 $imageB = Get-Image $imageId $imageVersion $null $site $cacheOk
9152
9153 if ($imageB -ne $null) {
9154 $image = Merge-Image $image $imageB
9155
9156 $script:relevantSites[$site.SiteId] = $site
9157 }
9158 }
9159
9160 return $image
9161 }
9162 catch {
9163 throw ("Error in Get-MergedImage: " + $error[0])
9164 }
9165} # Get-MergedImage
9166
9167
9168# If $imageType is provided, then $id and $version refer to the ImageSetVersion.
9169# Otherwise, $id and $version refer to the ImageVersion.
9170Function Get-Image ($id, $version, $imageType, $site, $cacheOk, $dbTran) {
9171 try {
9172 if ($imageType -eq $null) {
9173 $image = Select-Image $id $version $site.DbConn $dbTran
9174 }
9175 else {
9176 $image = Select-IsvdImage $id $version $imageType $site.DbConn $dbTran
9177 }
9178
9179 if ($image -ne $null) {$image.ImageFile = Get-ImageFile $image $site $cacheOk $dbTran}
9180
9181 return $image
9182 }
9183 catch {
9184 throw ("Error in Get-Image: " + $error[0])
9185 }
9186} # Get-Image
9187
9188
9189# Create blank object once, so it can be copied to create new instances.
9190# This results in huge performance gains.
9191$global:blankImage = New-Object PSObject
9192$global:blankImage | Add-Member NoteProperty ImageId $null
9193$global:blankImage | Add-Member NoteProperty Version $null
9194$global:blankImage | Add-Member NoteProperty IsLinked $null
9195$global:blankImage | Add-Member NoteProperty VersionCreated $null
9196$global:blankImage | Add-Member NoteProperty DateAccessed $null
9197$global:blankImage | Add-Member NoteProperty DivisionNumber $null
9198$global:blankImage | Add-Member NoteProperty OnlineDevice $null
9199$global:blankImage | Add-Member NoteProperty NearlineDevice $null
9200$global:blankImage | Add-Member NoteProperty Encrypted $null
9201$global:blankImage | Add-Member NoteProperty Critical $null
9202$global:blankImage | Add-Member NoteProperty PathDate $null
9203$global:blankImage | Add-Member NoteProperty SiteId $null
9204$global:blankImage | Add-Member NoteProperty ArchiveImmediate $null
9205$global:blankImage | Add-Member NoteProperty DeferStatic $null
9206$global:blankImage | Add-Member NoteProperty FileSize $null
9207$global:blankImage | Add-Member NoteProperty Rotation $null
9208$global:blankImage | Add-Member NoteProperty PreRotation $null
9209$global:blankImage | Add-Member NoteProperty ContentType $null
9210$global:blankImage | Add-Member NoteProperty Status $null
9211$global:blankImage | Add-Member NoteProperty Md5a $null
9212$global:blankImage | Add-Member NoteProperty Md5b $null
9213$global:blankImage | Add-Member NoteProperty CurrentVersion $null
9214$global:blankImage | Add-Member NoteProperty ImageCreated $null
9215$global:blankImage | Add-Member NoteProperty DynamicVersion $null
9216$global:blankImage | Add-Member NoteProperty Extension $null
9217$global:blankImage | Add-Member NoteProperty ImageType $null
9218$global:blankImage | Add-Member NoteProperty PlatterNearline $null
9219$global:blankImage | Add-Member NoteProperty PlatterId $null
9220$global:blankImage | Add-Member NoteProperty BurnedPathDate $null
9221$global:blankImage | Add-Member NoteProperty BurnedDivisionNumber $null
9222$global:blankImage | Add-Member NoteProperty ImageFile $null
9223
9224Function Select-Image ($imageId, $imageVersion, $dbConn, $dbTran) {
9225 try {
9226 $cmd = New-Object System.Data.SqlClient.SqlCommand
9227
9228 $cmd.CommandText = "
9229 select iv.datecreated versioncreated, iv.dateaccessed, iv.divisionnumber, iv.onlinedevice,
9230 iv.nearlinedevice, iv.encrypted, iv.critical, iv.pathdate, iv.siteid, iv.archiveimmediate,
9231 iv.deferstatic, iv.filesize, iv.rotation, iv.prerotation, iv.contenttype, iv.status, iv.md5a,
9232 iv.md5b, i.currentversion, i.datecreated imagecreated, i.dynamicversion, i.ext, i.type,
9233 p.nearlinedevice platternearline, p.platterid, bh.pathdate burnedpathdate,
9234 bh.divisionnumber burneddivisionnumber
9235 from ImageVersion iv
9236 join Image i on i.imageid = iv.imageid
9237 left join BurnHistory bh on bh.imageid = iv.imageid and bh.imageversion = iv.imageversion
9238 left join Platter p on p.platterid = bh.platterid
9239 where iv.imageid = @imageid
9240 and iv.imageversion = @imageversion
9241 "
9242
9243 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
9244 $cmd.Parameters["@imageid"].Value = $imageId
9245
9246 $cmd.Parameters.Add("@imageversion", [System.Data.SqlDbType]::Int) | Out-Null
9247 $cmd.Parameters["@imageversion"].Value = $imageVersion
9248
9249 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
9250 $cmd = (ConvertTo-OracleCommand $cmd)
9251 }
9252
9253 $cmd.Connection = $dbConn
9254 if ($dbTran) {$cmd.Transaction = $dbTran}
9255
9256 $reader = $cmd.ExecuteReader()
9257
9258 if ($reader.Read()) {
9259 $image = $global:blankImage.PSObject.Copy()
9260
9261 $image.ImageId = $imageId
9262 $image.Version = $imageVersion
9263 $image.IsLinked = $null
9264 $image.VersionCreated = ConvertTo-PsType $reader[0]
9265 $image.DateAccessed = ConvertTo-PsType $reader[1]
9266 $image.DivisionNumber = ConvertTo-PsType $reader[2]
9267 $image.OnlineDevice = ConvertTo-PsType $reader[3]
9268 $image.NearlineDevice = ConvertTo-PsType $reader[4]
9269 $image.Encrypted = ConvertTo-PsType $reader[5]
9270 $image.Critical = ConvertTo-PsType $reader[6]
9271 $image.PathDate = ConvertTo-PsType $reader[7]
9272 $image.SiteId = ConvertTo-PsType $reader[8]
9273 $image.ArchiveImmediate = ConvertTo-PsType $reader[9]
9274 $image.DeferStatic = ConvertTo-PsType $reader[10]
9275 $image.FileSize = ConvertTo-PsType $reader[11]
9276 $image.Rotation = ConvertTo-PsType $reader[12]
9277 $image.PreRotation = ConvertTo-PsType $reader[13]
9278 $image.ContentType = ConvertTo-PsType $reader[14]
9279 $image.Status = ConvertTo-PsType $reader[15]
9280 $image.Md5a = ConvertTo-PsType $reader[16]
9281 $image.Md5b = ConvertTo-PsType $reader[17]
9282 $image.CurrentVersion = ConvertTo-PsType $reader[18]
9283 $image.ImageCreated = ConvertTo-PsType $reader[19]
9284 $image.DynamicVersion = ConvertTo-PsType $reader[20]
9285 $image.Extension = ConvertTo-PsType $reader[21]
9286 $image.ImageType = ConvertTo-PsType $reader[22]
9287 $image.PlatterNearline = ConvertTo-PsType $reader[23]
9288 $image.PlatterId = ConvertTo-PsType $reader[24]
9289 $image.BurnedPathDate = ConvertTo-PsType $reader[25]
9290 $image.BurnedDivisionNumber = ConvertTo-PsType $reader[26]
9291 }
9292 else {
9293 $image = $null
9294 }
9295
9296 return $image
9297 }
9298 catch {
9299 throw ("Error in Select-Image: " + $error[0])
9300 }
9301 finally {
9302 if ($reader) {$reader.Close()}
9303 }
9304} # Select-Image
9305
9306
9307Function Select-IsvdImage ($imageSetId, $imageSetVersion, $imageType, $dbConn, $dbTran) {
9308 try {
9309 $cmd = New-Object System.Data.SqlClient.SqlCommand
9310
9311 $cmd.CommandText = "
9312 select isvd.imageid, isvd.imageversion, isvd.islinked, iv.datecreated versioncreated,
9313 iv.dateaccessed, iv.divisionnumber, iv.onlinedevice, iv.nearlinedevice, iv.encrypted, iv.critical,
9314 iv.pathdate, iv.siteid, iv.archiveimmediate, iv.deferstatic, iv.filesize, iv.rotation,
9315 iv.prerotation, iv.contenttype, iv.status, iv.md5a, iv.md5b, i.currentversion,
9316 i.datecreated imagecreated, i.dynamicversion, i.ext, i.type, p.nearlinedevice platternearline,
9317 p.platterid, bh.pathdate burnedpathdate, bh.divisionnumber burneddivisionnumber
9318 from ImageSetVersionData isvd
9319 join ImageVersion iv on iv.imageid = isvd.imageid and iv.imageversion = isvd.imageversion
9320 join Image i on i.imageid = isvd.imageid
9321 left join BurnHistory bh on bh.imageid = isvd.imageid and bh.imageversion = isvd.imageversion
9322 left join Platter p on p.platterid = bh.platterid
9323 where isvd.imagesetid = @imagesetid
9324 and isvd.imagesetversion = @imagesetversion
9325 and {ImageTypeCondition}
9326 "
9327
9328 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
9329 $cmd.Parameters["@imagesetid"].Value = $imageSetId
9330
9331 $cmd.Parameters.Add("@imagesetversion", [System.Data.SqlDbType]::Int) | Out-Null
9332 $cmd.Parameters["@imagesetversion"].Value = $imageSetVersion
9333
9334 if ($imageType -eq "Image") {
9335 $cmd.CommandText = $cmd.CommandText.Replace("{ImageTypeCondition}", "i.type in (0,4,5,6)")
9336 }
9337 elseif ($imageType -eq "Annotation") {
9338 $cmd.CommandText = $cmd.CommandText.Replace("{ImageTypeCondition}", "i.type = 1")
9339 }
9340 else {
9341 throw "Invalid image type specified: $imageType."
9342 }
9343
9344 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
9345 $cmd = (ConvertTo-OracleCommand $cmd)
9346 }
9347
9348 $cmd.Connection = $dbConn
9349 if ($dbTran) {$cmd.Transaction = $dbTran}
9350
9351 $reader = $cmd.ExecuteReader()
9352
9353 if ($reader.Read()) {
9354 $image = $global:blankImage.PSObject.Copy()
9355
9356 $image.ImageId = ConvertTo-PsType $reader[0]
9357 $image.Version = ConvertTo-PsType $reader[1]
9358 $image.IsLinked = ConvertTo-PsType $reader[2]
9359 $image.VersionCreated = ConvertTo-PsType $reader[3]
9360 $image.DateAccessed = ConvertTo-PsType $reader[4]
9361 $image.DivisionNumber = ConvertTo-PsType $reader[5]
9362 $image.OnlineDevice = ConvertTo-PsType $reader[6]
9363 $image.NearlineDevice = ConvertTo-PsType $reader[7]
9364 $image.Encrypted = ConvertTo-PsType $reader[8]
9365 $image.Critical = ConvertTo-PsType $reader[9]
9366 $image.PathDate = ConvertTo-PsType $reader[10]
9367 $image.SiteId = ConvertTo-PsType $reader[11]
9368 $image.ArchiveImmediate = ConvertTo-PsType $reader[12]
9369 $image.DeferStatic = ConvertTo-PsType $reader[13]
9370 $image.FileSize = ConvertTo-PsType $reader[14]
9371 $image.Rotation = ConvertTo-PsType $reader[15]
9372 $image.PreRotation = ConvertTo-PsType $reader[16]
9373 $image.ContentType = ConvertTo-PsType $reader[17]
9374 $image.Status = ConvertTo-PsType $reader[18]
9375 $image.Md5a = ConvertTo-PsType $reader[19]
9376 $image.Md5b = ConvertTo-PsType $reader[20]
9377 $image.CurrentVersion = ConvertTo-PsType $reader[21]
9378 $image.ImageCreated = ConvertTo-PsType $reader[22]
9379 $image.DynamicVersion = ConvertTo-PsType $reader[23]
9380 $image.Extension = ConvertTo-PsType $reader[24]
9381 $image.ImageType = ConvertTo-PsType $reader[25]
9382 $image.PlatterNearline = ConvertTo-PsType $reader[26]
9383 $image.PlatterId = ConvertTo-PsType $reader[27]
9384 $image.BurnedPathDate = ConvertTo-PsType $reader[28]
9385 $image.BurnedDivisionNumber = ConvertTo-PsType $reader[29]
9386 $image.ImageFile = $null
9387 }
9388 else {
9389 $image = $null
9390 }
9391
9392 return $image
9393 }
9394 catch {
9395 throw ("Error in Select-IsvdImage: " + $error[0])
9396 }
9397 finally {
9398 if ($reader) {$reader.Close()}
9399 }
9400} # Select-IsvdImage
9401
9402
9403Function Get-ImageFile ($image, $site, $cacheOk, $dbTran) {
9404 try {
9405 $device = $site.Devices | Where-Object {$_.DeviceId -eq $image.OnlineDevice}
9406
9407 if ($cacheOk -or $device.DeviceType -eq 0) {
9408 $imagePath = Get-ImagePath $image $device
9409
9410 if (Test-Path $imagePath) {$imageFile = Get-Item $imagePath}
9411 }
9412
9413 if ($image.ImageFile -eq $null) {
9414 $device = $site.Devices | Where-Object {$_.DeviceId -eq $image.NearlineDevice}
9415 $imagePath = Get-ImagePath $image $device
9416
9417 if (Test-Path $imagePath) {$imageFile = Get-Item $imagePath}
9418 }
9419
9420 if ($image.ImageFile -eq $null) {
9421 $device = $site.Devices | Where-Object {$_.DeviceId -eq $image.PlatterNearline}
9422 $imagePath = Get-ImagePath $image $device
9423
9424 if (Test-Path $imagePath) {$imageFile = Get-Item $imagePath}
9425 }
9426
9427 if ($image.ImageFile -eq $null -and $site.IsMigrated) {
9428 $image3x = Select-Image3x $image.ImageId $image.Version $site.DbConn $dbTran
9429
9430 if ($image3x) {
9431 $imagePath = "$($image3x.DeviceUrl)$($image3x.Path)"
9432
9433 if (Test-Path $imagePath) {$imageFile = Get-Item $imagePath}
9434 }
9435
9436 if ($image.ImageFile -eq $null -and $image3x) {
9437 $imagePath = "$($image3x.NearlineUrl)$($image3x.Platter)$($image3x.Path)"
9438
9439 if (Test-path $imagePath) {$imageFile = Get-Item $imagePath}
9440 }
9441 }
9442
9443 return $imageFile
9444 }
9445 catch {
9446 throw ("Error in Get-ImageFile: " + $error[0])
9447 }
9448} # Get-ImageFile
9449
9450
9451Function Get-ImagePath ($image, $device) {
9452 try {
9453 if ($image.ImageId -ne $null) {$imageIdHex = $image.ImageId.ToString('X8')}
9454 if ($image.Version -ne $null) {$imageVersionHex = $image.Version.ToString('X8')}
9455 if ($image.Extension -ne $null) {$extension = $image.Extension}
9456 if ($image.PathDate -ne $null) {$pathDateHex = $image.PathDate.ToString('X8')}
9457 if ($image.DivisionNumber -ne $null) {$divisionNumber = $image.DivisionNumber.ToString('D8')}
9458
9459 $imagePath = $device.UncPath
9460
9461 if ($device.DeviceType -eq 0 -and ($image.Critical -band 1) -eq 1) {
9462 $imagePath += "\Critical"
9463 }
9464 elseif ($device.DeviceType -eq 1 -and ($image.Critical -band 2) -eq 2) {
9465 $imagePath += "\Critical"
9466 }
9467 elseif ($device.DeviceType -eq 1 -and ($image.Critical -band 2) -eq 0) {
9468 $imagePath += "\$($image.PlatterId.ToString('D8'))"
9469 $pathDateHex = $image.BurnedPathDate.ToString('X8')
9470 $divisionNumber = $image.BurnedDivisionNumber.ToString('D8')
9471 }
9472
9473 $imagePath += "\$pathDateHex\$divisionNumber\$imageIdHex$imageVersionHex.$extension"
9474
9475 return $imagePath
9476 }
9477 catch {
9478 throw ("Error in Get-ImagePath: " + $error[0])
9479 }
9480} # Get-ImagePath
9481
9482
9483# Create blank object once, so it can be copied to create new instances.
9484# This results in huge performance gains.
9485$global:blankImage3x = New-Object PSObject
9486$global:blankImage3x | Add-Member NoteProperty ImageId $null
9487$global:blankImage3x | Add-Member NoteProperty Version $null
9488$global:blankImage3x | Add-Member NoteProperty Path $null
9489$global:blankImage3x | Add-Member NoteProperty DeviceUrl $null
9490$global:blankImage3x | Add-Member NoteProperty Platter $null
9491$global:blankImage3x | Add-Member NoteProperty NearlineUrl $null
9492
9493Function Select-Image3x ($imageId, $imageVersion, $dbConn, $dbTran) {
9494 try {
9495 $cmd = New-Object System.Data.SqlClient.SqlCommand
9496
9497 $cmd.CommandText = "
9498 select im3.path, dm3.baseurl deviceurl, im3.platter, nm3.baseurl nearlineurl
9499 from ImageMap3x im3
9500 left join DeviceMap3x dm3 on dm3.ir3xlinkid = im3.ir3xlinkid and dm3.deviceid = im3.device
9501 left join PlatterMap3x pm3 on pm3.ir3xlinkid = im3.ir3xlinkid and pm3.label = im3.platter
9502 left join NearlineMap3x nm3 on nm3.ir3xlinkid = pm3.ir3xlinkid and nm3.deviceid = pm3.nearlineid
9503 where im3.imageid = @imageid
9504 and im3.imageversion = @imageversion
9505 "
9506
9507 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
9508 $cmd.Parameters["@imageid"].Value = $imageId
9509
9510 $cmd.Parameters.Add("@imageversion", [System.Data.SqlDbType]::Int) | Out-Null
9511 $cmd.Parameters["@imageversion"].Value = $imageVersion
9512
9513 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
9514 $cmd = (ConvertTo-OracleCommand $cmd)
9515 }
9516
9517 $cmd.Connection = $dbConn
9518 if ($dbTran) {$cmd.Transaction = $dbTran}
9519
9520 $reader = $cmd.ExecuteReader()
9521
9522 if ($reader.Read()) {
9523 $image3x = $global:blankImage3x.PSObject.Copy()
9524
9525 $image3x.ImageId = $imageId
9526 $image3x.Version = $imageVersion
9527 $image3x.Path = ConvertTo-PsType $reader[0]
9528 $image3x.DeviceUrl = ConvertTo-PsType $reader[1]
9529 $image3x.Platter = ConvertTo-PsType $reader[2]
9530 $image3x.NearlineUrl = ConvertTo-PsType $reader[3]
9531 }
9532 else {
9533 $image = $null
9534 }
9535
9536 return $image3x
9537 }
9538 catch {
9539 throw ("Error in Select-Image3x: " + $error[0])
9540 }
9541 finally {
9542 if ($reader) {$reader.Close()}
9543 }
9544} # Select-Image3x
9545
9546
9547Function Merge-ImageSet ($imageSet1, $imageSet2) {
9548 try {
9549 if ($imageSet1.ImageSetId -ne $imageSet2.ImageSetId) {
9550 throw "Cannot merge imagesets with different imagesetids."
9551 }
9552
9553 if ($imageSet1.Owner -eq $imageSet1.SiteId -and $imageSet2.Owner -ne $imageSet2.SiteId) {
9554 $imageSet1.EncryptionKey = Merge-Value $imageSet1.EncryptionKey $imageSet2.EncryptionKey "ReplaceNull"
9555 $imageSet1.BatchId = Merge-Value $imageSet1.BatchId $imageSet2.BatchId "ReplaceNull"
9556 }
9557 else {
9558 $imageSet1.EncryptionKey = Merge-Value $imageSet2.EncryptionKey $imageSet1.EncryptionKey "ReplaceNull"
9559 $imageSet1.BatchId = Merge-Value $imageSet2.BatchId $imageSet1.BatchId "ReplaceNull"
9560 }
9561
9562 $maxVersion = (($imageSet1.Versions.Keys + $imageSet2.Versions.Keys) | Measure-Object -Maximum).Maximum
9563 $imageSet1.CurrentVersion = $maxVersion
9564
9565 for ($i = 0; $i -le $maxVersion; $i++) {
9566 if ($imageSet1.Versions[$i] -eq $null) {
9567 $imageSet1.Versions[$i] = $imageSet2.Versions[$i]
9568 }
9569 elseif ($imageSet2.Versions[$i] -eq $null) {
9570 <# Keep $imageSet1.Versions[$i]. #>
9571 }
9572 elseif ($imageSet1.Owner -eq $imageSet1.SiteId -and $imageSet2.Owner -ne $imageSet2.SiteId) {
9573 $imageSet1.Versions[$i] = Merge-ImageSetVersion $imageSet1.Versions[$i] $imageSet2.Versions[$i]
9574 }
9575 else {
9576 $imageSet1.Versions[$i] = Merge-ImageSetVersion $imageSet2.Versions[$i] $imageSet1.Versions[$i]
9577 $imageSet1.SiteId = $imageSet2.SiteId
9578 }
9579 }
9580
9581 return $imageSet1
9582 }
9583 catch {
9584 throw ("Error in Merge-ImageSet: " + $error[0])
9585 }
9586} # Merge-ImageSet
9587
9588
9589Function Merge-ImageSetVersion ($isv1, $isv2) {
9590 try {
9591 if ($isv1.ImageSetId -ne $isv2.ImageSetId -or $isv1.Version -ne $isv2.Version) {
9592 throw "Cannot merge imagesetversions with different imagesetids or versions."
9593 }
9594
9595 $isv1.DateChanged = Merge-Value $isv1.DateChanged $isv2.DateChanged "ReplaceNull" "Lesser"
9596
9597 if ($isv1.Image -eq $null) {
9598 $isv1.Image = $isv2.Image
9599 }
9600 elseif ($isv1.Image -ne $null -and $isv2.Image -ne $null) {
9601 $isv1.Image = Merge-Image $isv1.Image $isv2.Image
9602 }
9603
9604 if ($isv1.Annotation -eq $null -and $isv2.Annotation -ne $null) {
9605 $isv1.Annotation = $isv2.Annotation
9606 }
9607 elseif ($isv1.Annotation -ne $null -and $isv2.Annotation -ne $null) {
9608 $isv1.Annotation = Merge-Image $isv1.Annotation $isv2.Annotation
9609 }
9610
9611 return $isv1
9612 }
9613 catch {
9614 throw ("Error in Merge-ImageSetVersion: " + $error[0])
9615 }
9616} # Merge-ImageSetVersion
9617
9618
9619Function Merge-Image ($image1, $image2) {
9620 try {
9621 if ($image1.ImageId -eq $null -or $image2.ImageId -eq $null) {
9622 throw "Cannot merge images without imageids."
9623 }
9624 elseif ($image1.Version -lt $image2.Version) {
9625 $image1 = $image2
9626 }
9627 elseif ($image1.ImageFile -eq $null -and $image2.ImageFile -ne $null) {
9628 $image1 = $image2
9629 }
9630 elseif ($image1.ImageFile -ne $null -and $image2.ImageFile -eq $null) {
9631 # Keep $image1.
9632 }
9633 elseif ($image1.ImageFile.Length -eq 0 -and $image2.ImageFile.Length -gt 0) {
9634 $image1 = $image2
9635 }
9636 elseif ($image1.ImageId -ne $image2.ImageId) {
9637 if ($image1.IsLinked -eq 1 -and $image2.IsLinked -eq 0) {$image1 = $image2}
9638 else {<# Keep $image1. #>}
9639 }
9640 else {
9641 # Keep $image1.
9642 }
9643
9644 if ($image1.VersionCreated -gt $image2.VersionCreated) {$image1.VersionCreated = $image2.VersionCreated}
9645 if ($image1.DateAccessed -lt $image2.DateAccessed) {$image1.DateAccessed = $image2.DateAccessed}
9646 if ($image1.Encrypted.Length -eq 0 -and $image2.Encrypted.Length -gt 0) {$image1.Encrypted = $image2.Encrypted}
9647 if ($image1.Rotation -lt $image2.Rotation) {$image1.Rotation = $image2.Rotation}
9648 if ($image1.PreRotation -lt $image2.PreRotation) {$image1.PreRotation = $image2.PreRotation}
9649 if ($image1.ContentType -eq 0 -and $image2.ContentType -gt 0) {$image1.ContentType = $image2.ContentType}
9650
9651 if ($image1.Version -gt $image1.CurrentVersion) {$image1.CurrentVersion = $image1.Version}
9652 if ($image1.ImageCreated -gt $image2.ImageCreated) {$image1.ImageCreated = $image2.ImageCreated}
9653
9654 return $image1
9655 }
9656 catch {
9657 throw ("Error in Merge-Image: " + $error[0])
9658 }
9659} # Merge-Image
9660
9661
9662Function Get-MergedPageByImageSet ($imageSetId, $sites) {
9663 try {
9664 $siteQueue = New-Object System.Collections.Queue
9665 $page = $null
9666
9667 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
9668
9669 while ($siteQueue.Count -gt 0 -and $page -eq $null) {
9670 $site = $siteQueue.Dequeue()
9671 $page = Select-PageByImageSet $imageSetId $site.DbConn
9672 }
9673
9674 return $page
9675 }
9676 catch {
9677 throw ("Error in Get-MergedPageByImageSet: " + $error[0])
9678 }
9679} # Get-MergedPageByImageSet
9680
9681
9682Function Select-PageByImageSet ($imageSetId, $dbConn) {
9683 try {
9684 $cmd = New-Object System.Data.SqlClient.SqlCommand
9685
9686 $cmd.CommandText = "
9687 select pageid, description, pagenumber, imagesetid, lastmodified, created, documentid, isdeleted
9688 from Pages
9689 where imagesetid = @imagesetid
9690 "
9691
9692 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
9693 $cmd.Parameters["@imagesetid"].Value = $imageSetId
9694
9695 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
9696 $cmd = (ConvertTo-OracleCommand $cmd)
9697 }
9698
9699 $cmd.Connection = $dbConn
9700
9701 $reader = $cmd.ExecuteReader()
9702
9703 if ($reader.Read()) {
9704 $page = $global:blankPage.PSObject.Copy()
9705
9706 $page.ItemId = ConvertTo-PsType $reader[0]
9707 $page.Description = ConvertTo-PsType $reader[1]
9708 $page.PageNumber = ConvertTo-PsType $reader[2]
9709 $page.ImageSetId = ConvertTo-PsType $reader[3]
9710 $page.LastModified = ConvertTo-PsType $reader[4]
9711 $page.Created = ConvertTo-PsType $reader[5]
9712 $page.DocumentId = ConvertTo-PsType $reader[6]
9713 $page.IsDeleted = ConvertTo-PsType $reader[7]
9714 }
9715 else {
9716 $page = $null
9717 }
9718
9719 return $page
9720 }
9721 catch {
9722 throw ("Error in Select-PageByImageSet: " + $error[0])
9723 }
9724 finally {
9725 if ($reader) {$reader.Close()}
9726 }
9727} # Select-PageByImageSet
9728
9729
9730Function Get-MergedOriginalPage ($page, $sites) {
9731 try {
9732 $siteQueue = New-Object System.Collections.Queue
9733 $originalPage = $null
9734
9735 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
9736
9737 while ($siteQueue.Count -gt 0 -and $originalPage -eq $null) {
9738 $site = $siteQueue.Dequeue()
9739 $originalPage = Get-OriginalPage $page $site
9740 }
9741
9742 return $originalPage
9743 }
9744 catch {
9745 throw ("Error in Get-MergedOriginalPage: " + $error[0])
9746 }
9747} # Get-MergedOriginalPage
9748
9749
9750Function Get-OriginalPage ($page, $site) {
9751 try {
9752 $document = Select-DocumentPlus $page.DocumentId $site.DbConn
9753 $candidatePage = $null
9754
9755 $candidatePages = Select-PagesByDateCreated $page.Created $site.DbConn | Where-Object {$_.ImageSetId -ne $page.ImageSetId}
9756
9757 if ($candidatePages.Length -gt 0) {
9758 $candidatePage = $candidatePages[0]
9759 $candidateImageSet = Get-ImageSet $candidatePage.ImageSetId $site
9760 $candidateDocument = Select-DocumentPlus $candidatePage.DocumentId $site.DbConn
9761 }
9762 else {
9763 $candidatePage = $null
9764 $candidateImageSet = $null
9765 $candidateDocument = $null
9766 }
9767
9768 for ($i = 1; $i -lt $candidatePages.Length; $i++) {
9769 $candidatePageB = $candidatePages[$i]
9770 $candidateImageSetB = Get-ImageSet $candidatePageB.ImageSetId $site
9771 $candidateDocumentB = Select-DocumentPlus $candidatePageB.DocumentId $site.DbConn
9772
9773 # If the current candidate page doesn't have associated ImageSetVersions, then skip it.
9774 if ($candidateImageSet.Versions.Count -in ($null,0)) { ############################################################## -or $candidateImageSet.Versions[0].Image.ImageFile -eq $null
9775 $candidatePage = $candidatePageB
9776 $candidateImageSet = $candidateImageSetB
9777 $candidateDocument = $candidateDocumentB
9778 }
9779 elseif ($candidateImageSetB.Versions.Count -in ($null,0)) { ################################################################# -or $candidateImageSetB.Versions[0].Image.ImageFile -eq $null
9780 # Skip this.
9781 }
9782 elseif (Test-ImageSetsAreCopies $candidateImageSet $candidateImageSetB) {
9783 # Both candidates are copies, so it doesn't matter which one we choose.
9784 }
9785 elseif ($page.LastModified -ne $candidatePage.LastModified -and $page.LastModified -eq $candidatePageB.LastModified) {
9786 $candidatePage = $candidatePageB
9787 $candidateImageSet = $candidateImageSetB
9788 $candidateDocument = $candidateDocumentB
9789 }
9790 elseif ($page.Description -ne $candidatePage.Description -and $page.Description -eq $candidatePageB.Description) {
9791 $candidatePage = $candidatePageB
9792 $candidateImageSet = $candidateImageSetB
9793 $candidateDocument = $candidateDocumentB
9794 }
9795 elseif ($document.Created -ne $candidateDocument.Created -and $document.Created -eq $candidateDocumentB.Created) {
9796 $candidatePage = $candidatePageB
9797 $candidateImageSet = $candidateImageSetB
9798 $candidateDocument = $candidateDocumentB
9799 }
9800 elseif ($document.LastModified -ne $candidateDocument.LastModified -and $document.LastModified -eq $candidateDocumentB.LastModified) {
9801 $candidatePage = $candidatePageB
9802 $candidateImageSet = $candidateImageSetB
9803 $candidateDocument = $candidateDocumentB
9804 }
9805 elseif ($document.Description -ne $candidateDocument.Description -and $document.Description -eq $candidateDocumentB.Description) {
9806 $candidatePage = $candidatePageB
9807 $candidateImageSet = $candidateImageSetB
9808 $candidateDocument = $candidateDocumentB
9809 }
9810 elseif ($document.PageCount -ne $candidateDocument.PageCount -and $document.PageCount -eq $candidateDocumentB.PageCount) {
9811 $candidatePage = $candidatePageB
9812 $candidateImageSet = $candidateImageSetB
9813 $candidateDocument = $candidateDocumentB
9814 }
9815 }
9816
9817 return $candidatePage
9818 }
9819 catch {
9820 throw ("Error in Get-OriginalPage: " + $error[0])
9821 }
9822} # Get-OriginalPage
9823
9824
9825# Create blank object once, so it can be copied to create new instances.
9826# This results in huge performance gains.
9827$global:blankDocumentPlus = New-Object PSObject
9828$global:blankDocumentPlus | Add-Member NoteProperty DocumentId $null
9829$global:blankDocumentPlus | Add-Member NoteProperty PageCount $null
9830$global:blankDocumentPlus | Add-Member NoteProperty DocumentDate $null
9831$global:blankDocumentPlus | Add-Member NoteProperty ParentId $null
9832$global:blankDocumentPlus | Add-Member NoteProperty Description $null
9833$global:blankDocumentPlus | Add-Member NoteProperty LastModified $null
9834$global:blankDocumentPlus | Add-Member NoteProperty FileId $null
9835$global:blankDocumentPlus | Add-Member NoteProperty Created $null
9836$global:blankDocumentPlus | Add-Member NoteProperty Permissions $null
9837$global:blankDocumentPlus | Add-Member NoteProperty IsDeleted $null
9838
9839Function Select-DocumentPlus ($documentId, $dbConn) {
9840 try {
9841 $cmd = New-Object System.Data.SqlClient.SqlCommand
9842
9843 $cmd.CommandText = "
9844 select d.docfolderid, d.pagecount, d.documentdate, df.parentid, df.description,
9845 df.lastmodified, df.fileid, df.created, df.permissions, df.isdeleted
9846 from Document d
9847 join DocFolder df on df.docfolderid = d.docfolderid
9848 where d.docfolderid = @documentid
9849 "
9850
9851 $cmd.Parameters.Add("@documentid", [System.Data.SqlDbType]::Int) | Out-Null
9852 $cmd.Parameters["@documentid"].Value = $documentId
9853
9854 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
9855 $cmd = (ConvertTo-OracleCommand $cmd)
9856 }
9857
9858 $cmd.Connection = $dbConn
9859
9860 $reader = $cmd.ExecuteReader()
9861
9862 if ($reader.Read()) {
9863 $document = $global:blankDocumentPlus.PSObject.Copy()
9864
9865 $document.DocumentId = ConvertTo-PsType $reader[0]
9866 $document.PageCount = ConvertTo-PsType $reader[1]
9867 $document.DocumentDate = ConvertTo-PsType $reader[2]
9868
9869 $document.ParentId = ConvertTo-PsType $reader[3]
9870 $document.Description = ConvertTo-PsType $reader[4]
9871 $document.LastModified = ConvertTo-PsType $reader[5]
9872 $document.FileId = ConvertTo-PsType $reader[6]
9873 $document.Created = ConvertTo-PsType $reader[7]
9874 $document.Permissions = ConvertTo-PsType $reader[8]
9875 $document.IsDeleted = ConvertTo-PsType $reader[9]
9876 }
9877 else {
9878 $document = $null
9879 }
9880
9881 return $document
9882 }
9883 catch {
9884 throw ("Error in Select-DocumentPlus: " + $error[0])
9885 }
9886 finally {
9887 if ($reader) {$reader.Close()}
9888 }
9889} # Select-DocumentPlus
9890
9891
9892Function Select-PagesByDateCreated ($dateCreated, $dbConn) {
9893 try {
9894 $cmd = New-Object System.Data.SqlClient.SqlCommand
9895
9896 $cmd.CommandText = "
9897 select pageid, description, pagenumber, imagesetid, lastmodified, created, documentid, isdeleted
9898 from Pages p (nolock)
9899 where created = @created
9900 "
9901
9902 $cmd.Parameters.Add("@created", [System.Data.SqlDbType]::DateTime) | Out-Null
9903 $cmd.Parameters["@created"].Value = $dateCreated
9904
9905 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
9906 $cmd = (ConvertTo-OracleCommand $cmd)
9907 }
9908
9909 $cmd.Connection = $dbConn
9910 $cmd.CommandTimeout = 500
9911
9912 $reader = $cmd.ExecuteReader()
9913
9914 $pages = @()
9915
9916 while ($reader.Read()) {
9917 $page = $global:blankPage.PSObject.Copy()
9918
9919 $page.ItemId = ConvertTo-PsType $reader[0]
9920 $page.Description = ConvertTo-PsType $reader[1]
9921 $page.PageNumber = ConvertTo-PsType $reader[2]
9922 $page.ImageSetId = ConvertTo-PsType $reader[3]
9923 $page.LastModified = ConvertTo-PsType $reader[4]
9924 $page.Created = ConvertTo-PsType $reader[5]
9925 $page.DocumentId = ConvertTo-PsType $reader[6]
9926 $page.IsDeleted = ConvertTo-PsType $reader[7]
9927
9928 $pages += $page
9929 }
9930
9931 return ,$pages # The comma ensures an array is returned even if there is only one element.
9932 }
9933 catch {
9934 throw ("Error in Select-PagesByDateCreated: " + $error[0])
9935 }
9936 finally {
9937 if ($reader) {$reader.Close()}
9938 }
9939} # Select-PagesByDateCreated
9940
9941
9942Function Test-ImageSetsAreCopies ($imageSet1, $imageSet2) {
9943 try {
9944 if ($imageSet1.Versions.Count -ne $imageSet2.Versions.Count) {return $false}
9945
9946 for ($i = 0; $i -lt $imageSet1.Versions.Count; $i++) {
9947 if ($imageSet1.Versions[$i].Image.Md5a -ne $imageSet2.Versions[$i].Image.Md5a) {return $false}
9948 if ($imageSet1.Versions[$i].Image.Md5b -ne $imageSet2.Versions[$i].Image.Md5b) {return $false}
9949 if ($imageSet1.Versions[$i].Image.FileSize -ne $imageSet2.Versions[$i].Image.FileSize) {return $false}
9950
9951 if ($imageSet1.Versions[$i].Annotation.Md5a -ne $imageSet2.Versions[$i].Annotation.Md5a) {return $false}
9952 if ($imageSet1.Versions[$i].Annotation.Md5b -ne $imageSet2.Versions[$i].Annotation.Md5b) {return $false}
9953 if ($imageSet1.Versions[$i].Annotation.FileSize -ne $imageSet2.Versions[$i].Annotation.FileSize) {return $false}
9954 }
9955
9956 return $true
9957 }
9958 catch {
9959 throw ("Error in Test-ImageSetsAreCopies: " + $error[0])
9960 }
9961} # Test-ImageSetsAreCopies
9962
9963
9964Function Get-MergedParentOwner ($imageSetId, $sites) {
9965 try {
9966 $siteQueue = New-Object System.Collections.Queue
9967 $parentOwner = $null
9968
9969 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
9970
9971 while ($siteQueue.Count -gt 0 -and $parentOwner -eq $null) {
9972 $site = $siteQueue.Dequeue()
9973 $parentOwner = Select-ParentOwner $imageSetId $site.DbConn
9974
9975 if ($parentOwner -eq 0 -and $site.SiteId -ne 0) {$parentOwner = $null}
9976 }
9977
9978 while ($siteQueue.Count -gt 0) {
9979 $site = $siteQueue.Dequeue()
9980 $parentOwnerB = Select-ParentOwner $imageSetId $site.DbConn
9981
9982 if ($parentOwnerB -eq 0 -and $site.SiteId -ne 0) {$parentOwnerB = $null}
9983
9984 # If more than one owner is found, use Master as the owner.
9985 if ($parentOwnerB -ne $null -and $parentOwner -ne $parentOwnerB) {$parentOwner = 0}
9986 }
9987
9988 if ($parentOwner -eq $null) {$parentOwner = 0}
9989
9990 return $parentOwner
9991 }
9992 catch {
9993 throw ("Error in Get-MergedParentOwner: " + $error[0])
9994 }
9995} # Get-MergedParentOwner
9996
9997
9998Function Select-ParentOwner ($imageSetId, $dbConn) {
9999 try {
10000 $cmd = New-Object System.Data.SqlClient.SqlCommand
10001
10002 $cmd.CommandText = "
10003 select f.owner
10004 from Pages p
10005 join DocFolder df on df.docfolderid = p.documentid
10006 join Files f on f.fileid = df.fileid
10007 where p.imagesetid = @imagesetid
10008 union
10009 select f.owner
10010 from ObjectNotesDetail ond
10011 join ObjectNotes ont on ont.noteid = ond.noteid
10012 join DocFolder df on df.docfolderid = ont.objectid
10013 join Files f on f.fileid = df.fileid
10014 where ond.imagesetid = @imagesetid
10015 union
10016 select f.owner
10017 from ObjectNotesDetail ond
10018 join ObjectNotes ont on ont.noteid = ond.noteid
10019 join Files f on f.fileid = ont.objectid
10020 where ond.imagesetid = @imagesetid
10021 union
10022 select f.owner
10023 from TaskMaster tm
10024 join TaskHistory th on th.taskid = tm.taskid
10025 join Files f on f.fileid = th.fileid
10026 where tm.imagesetid = @imagesetid
10027 "
10028
10029 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
10030 $cmd.Parameters["@imagesetid"].Value = $imageSetId
10031
10032 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10033 $cmd = (ConvertTo-OracleCommand $cmd)
10034 }
10035
10036 $cmd.Connection = $dbConn
10037
10038 $reader = $cmd.ExecuteReader()
10039
10040 if ($reader.Read()) {$owner = ConvertTo-PsType $reader[0]}
10041
10042 # If more than one owner is returned, we'll choose Master as the owner.
10043 if ($reader.Read()) {$owner = 0}
10044
10045 return $owner
10046 }
10047 catch {
10048 throw ("Error in Select-ParentOwner: " + $error[0])
10049 }
10050 finally {
10051 if ($reader) {$reader.Close()}
10052 }
10053} # Select-ParentOwner
10054
10055
10056Function Get-MergedNonLinkedOwner ($imageId, $sites) {
10057 try {
10058 $siteQueue = New-Object System.Collections.Queue
10059
10060 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
10061
10062 $owners = @()
10063
10064 while ($siteQueue.Count -gt 0) {
10065 $site = $siteQueue.Dequeue()
10066 $owners += Select-NonLinkedOwners $imageId $site.DbConn
10067 }
10068
10069 if (($owners | Sort-Object | Get-Unique).Count -eq 1) {return $owners[0]}
10070 else {return $null}
10071 }
10072 catch {
10073 throw ("Error in Get-MergedNonLinkedOwner: " + $error[0])
10074 }
10075} # Get-MergedNonLinkedOwner
10076
10077
10078Function Select-NonLinkedOwners ($imageId, $dbConn) {
10079 try {
10080 $cmd = New-Object System.Data.SqlClient.SqlCommand
10081
10082 $cmd.CommandText = "
10083 select distinct ist.owner
10084 from ImageSetVersionData isvd
10085 join ImageSet ist on ist.imagesetid = isvd.imagesetid
10086 where isvd.imageid = @imageid
10087 and isvd.islinked = 0
10088 "
10089
10090 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
10091 $cmd.Parameters["@imageid"].Value = $imageId
10092
10093 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10094 $cmd = (ConvertTo-OracleCommand $cmd)
10095 }
10096
10097 $cmd.Connection = $dbConn
10098
10099 $reader = $cmd.ExecuteReader()
10100
10101 $owners = @()
10102
10103 while ($reader.Read()) {$owners += ConvertTo-PsType $reader[0]}
10104
10105 return ,$owners # The comma ensures an array is returned even if there is only one element.
10106 }
10107 catch {
10108 throw ("Error in Select-NonLinkedOwners: " + $error[0])
10109 }
10110 finally {
10111 if ($reader) {$reader.Close()}
10112 }
10113} # Select-NonLinkedOwners
10114
10115
10116Function New-ImageId ($site) {
10117 try {
10118 $dbConn = $site.DbConn
10119 $dbTran = $dbConn.BeginTransaction()
10120
10121 Increment-KeyType 4 $dbConn $dbTran | Out-Null
10122
10123 $imageKeyType = Select-KeyType 4 $dbConn $dbTran
10124
10125 $newImageId = $imageKeyType.NextKey - 1
10126
10127 $dbTran.Commit()
10128
10129 return $newImageId
10130 }
10131 catch {
10132 if ($dbTran) {$dbTran.Rollback()}
10133 throw ("Error in New-ImageId: " + $error[0])
10134 }
10135} # New-ImageId
10136
10137
10138Function Increment-KeyType ($keyTypeId, $dbConn, $dbTran) {
10139 try {
10140 $cmd = New-Object System.Data.SqlClient.SqlCommand
10141
10142 $cmd.CommandText = "
10143 update KeyTypes
10144 set nextkey = nextkey + 1, keycount = keycount - 1
10145 where keytype = @keytypeid
10146 and setid = 0
10147 "
10148
10149 $cmd.Parameters.Add("@keytypeid", [System.Data.SqlDbType]::Int) | Out-Null
10150 $cmd.Parameters["@keytypeid"].Value = $keyTypeId
10151
10152 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10153 $cmd = (ConvertTo-OracleCommand $cmd)
10154 }
10155
10156 $cmd.Connection = $dbConn
10157 $cmd.Transaction = $dbTran
10158
10159 $rowsAffected = $cmd.ExecuteNonQuery()
10160
10161 return $rowsAffected
10162 }
10163 catch {
10164 throw ("Error in Increment-KeyType: " + $error[0])
10165 }
10166} # Increment-KeyType
10167
10168
10169Function Select-KeyType ($keyTypeId, $dbConn, $dbTran) {
10170 try {
10171 $cmd = New-Object System.Data.SqlClient.SqlCommand
10172
10173 $cmd.CommandText = "
10174 select nextkey, keycount
10175 from KeyTypes
10176 where keytype = @keytypeid
10177 and setid = 0
10178 "
10179
10180 $cmd.Parameters.Add("@keytypeid", [System.Data.SqlDbType]::Int) | Out-Null
10181 $cmd.Parameters["@keytypeid"].Value = $keyTypeId
10182
10183 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10184 $cmd = (ConvertTo-OracleCommand $cmd)
10185 }
10186
10187 $cmd.Connection = $dbConn
10188 $cmd.Transaction = $dbTran
10189
10190 $reader = $cmd.ExecuteReader()
10191
10192 if ($reader.Read()) {
10193 $keyType = New-Object PSObject
10194 $keyType | Add-Member NoteProperty KeyTypeId $keyTypeId
10195 $keyType | Add-Member NoteProperty SetId 0
10196 $keyType | Add-Member NoteProperty NextKey (ConvertTo-PsType $reader[0])
10197 $keyType | Add-Member NoteProperty KeyCount (ConvertTo-PsType $reader[1])
10198 }
10199 else {
10200 $keyType = $null
10201 }
10202
10203 return $keyType
10204 }
10205 catch {
10206 throw ("Error in Select-KeyType: " + $error[0])
10207 }
10208 finally {
10209 if ($reader) {$reader.Close()}
10210 }
10211} # Select-KeyType
10212
10213
10214Function Select-KeyTypes ($dbConn) {
10215 try {
10216 $cmd = New-Object System.Data.SqlClient.SqlCommand
10217
10218 $cmd.CommandText = "
10219 select keytype, nextkey, keycount
10220 from KeyTypes
10221 where setid = 0
10222 "
10223
10224 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10225 $cmd = (ConvertTo-OracleCommand $cmd)
10226 }
10227
10228 $cmd.Connection = $dbConn
10229
10230 $reader = $cmd.ExecuteReader()
10231
10232 $keyTypeArray = @()
10233
10234 while ($reader.Read()) {
10235 $keyType = New-Object PSObject
10236 $keyType | Add-Member NoteProperty KeyTypeId (ConvertTo-PsType $reader[0])
10237 $keyType | Add-Member NoteProperty SetId 0
10238 $keyType | Add-Member NoteProperty NextKey (ConvertTo-PsType $reader[1])
10239 $keyType | Add-Member NoteProperty KeyCount (ConvertTo-PsType $reader[2])
10240
10241 $keyTypeArray += $keyType
10242 }
10243
10244 return ,$keyTypeArray # The comma ensures an array is returned even if there is only one element.
10245 }
10246 catch {
10247 throw ("Error in Select-KeyTypes: " + $error[0])
10248 }
10249 finally {
10250 if ($reader) {$reader.Close()}
10251 }
10252} # Select-KeyTypes
10253
10254
10255Function Update-KeyType ($keyType, $dbConn) {
10256 try {
10257 $cmd = New-Object System.Data.SqlClient.SqlCommand
10258
10259 $cmd.CommandText = "
10260 update KeyTypes
10261 set nextkey = @nextkey, keycount = @keycount
10262 where keytype = @keytypeid
10263 and setid = @setid
10264 "
10265
10266 $cmd.Parameters.Add("@nextkey", [System.Data.SqlDbType]::Int) | Out-Null
10267 $cmd.Parameters["@nextkey"].Value = $keyType.NextKey
10268
10269 $cmd.Parameters.Add("@keycount", [System.Data.SqlDbType]::Int) | Out-Null
10270 $cmd.Parameters["@keycount"].Value = $keyType.KeyCount
10271
10272 $cmd.Parameters.Add("@keytypeid", [System.Data.SqlDbType]::Int) | Out-Null
10273 $cmd.Parameters["@keytypeid"].Value = $keyType.KeyTypeId
10274
10275 $cmd.Parameters.Add("@setid", [System.Data.SqlDbType]::Int) | Out-Null
10276 $cmd.Parameters["@setid"].Value = $keyType.SetId
10277
10278 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10279 $cmd = (ConvertTo-OracleCommand $cmd)
10280 }
10281
10282 $cmd.Connection = $dbConn
10283 $cmd.Transaction = $dbTran
10284
10285 $rowsAffected = $cmd.ExecuteNonQuery()
10286
10287 return $rowsAffected
10288 }
10289 catch {
10290 throw ("Error in Update-KeyType: " + $error[0])
10291 }
10292} # Update-KeyType
10293
10294
10295Function Insert-KeyType ($keyType, $dbConn) {
10296 try {
10297 $cmd = New-Object System.Data.SqlClient.SqlCommand
10298
10299 $cmd.CommandText = "
10300 insert into KeyTypes (keytype, setid, nextkey, keycount)
10301 values (@keytypeid, @setid, @nextkey, @keycount)
10302 "
10303
10304 $cmd.Parameters.Add("@keytypeid", [System.Data.SqlDbType]::Int) | Out-Null
10305 $cmd.Parameters["@keytypeid"].Value = $keyType.KeyTypeId
10306
10307 $cmd.Parameters.Add("@setid", [System.Data.SqlDbType]::Int) | Out-Null
10308 $cmd.Parameters["@setid"].Value = $keyType.SetId
10309
10310 $cmd.Parameters.Add("@nextkey", [System.Data.SqlDbType]::Int) | Out-Null
10311 $cmd.Parameters["@nextkey"].Value = $keyType.NextKey
10312
10313 $cmd.Parameters.Add("@keycount", [System.Data.SqlDbType]::Int) | Out-Null
10314 $cmd.Parameters["@keycount"].Value = $keyType.KeyCount
10315
10316 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10317 $cmd = (ConvertTo-OracleCommand $cmd)
10318 }
10319
10320 $cmd.Connection = $dbConn
10321 $cmd.Transaction = $dbTran
10322
10323 $rowsAffected = $cmd.ExecuteNonQuery()
10324
10325 return $rowsAffected
10326 }
10327 catch {
10328 throw ("Error in Insert-KeyType: " + $error[0])
10329 }
10330} # Insert-KeyType
10331
10332
10333Function Get-MergedLinkedImageSets ($imageId, $sites) {
10334 try {
10335 $siteQueue = New-Object System.Collections.Queue
10336 $imageSetTable = @{}
10337
10338 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
10339
10340 while ($siteQueue.Count -gt 0) {
10341 $site = $siteQueue.Dequeue()
10342 $siteImageSets = Select-LinkedImageSets $imageId $site.DbConn
10343
10344 $siteImageSets | ForEach-Object {
10345 $imageSet = $_
10346 $imageSetId = $imageSet.ImageSetId
10347
10348 if ($imageSetId -notin $imageSetTable.Keys) {
10349 $imageSetTable[$imageSetId] = $imageSet
10350 }
10351 else {
10352 if ($imageSet.Owner -eq $site.SiteId) {$imageSetTable[$imageSetId].Owner = $imageSet.Owner}
10353
10354 if ($imageSet.IsLinked -eq 0) {$imageSetTable[$imageSetId].IsLinked = 0}
10355
10356 if ($imageSet.MaxImageVersion -gt $imageSetTable[$imageSetId].MaxImageVersion) {
10357 $imageSetTable[$imageSetId].MaxImageVersion = $imageSet.MaxImageVersion
10358 }
10359 }
10360 }
10361 }
10362
10363 $linkedImageSets = $imageSetTable.Values | Sort-Object -Property @{Expression="MaxImageVersion";Descending=$true}, "IsLinked", "ImageSetId"
10364
10365 return ,$linkedImageSets # The comma ensures an array is returned even if there is only one element.
10366 }
10367 catch {
10368 throw ("Error in Get-MergedLinkedImageSets: " + $error[0])
10369 }
10370} # Get-MergedLinkedImageSets
10371
10372
10373# Create blank object once, so it can be copied to create new instances.
10374# This results in huge performance gains.
10375$global:blankLinkedImageSet = New-Object PSObject
10376$global:blankLinkedImageSet | Add-Member NoteProperty ImageSetId $null
10377$global:blankLinkedImageSet | Add-Member NoteProperty IsLinked $null
10378$global:blankLinkedImageSet | Add-Member NoteProperty Owner $null
10379$global:blankLinkedImageSet | Add-Member NoteProperty MaxImageVersion $null
10380
10381Function Select-LinkedImageSets ($imageId, $dbConn) {
10382 try {
10383 $cmd = New-Object System.Data.SqlClient.SqlCommand
10384
10385 $cmd.CommandText = "
10386 select isvd.imagesetid, isvd.islinked, ist.owner, max(isvd.imageversion) maximageversion
10387 from ImageSetVersionData isvd
10388 join ImageSet ist on ist.imagesetid = isvd.imagesetid
10389 where isvd.imageid = @imageid
10390 group by isvd.imagesetid, isvd.islinked, ist.owner
10391 order by maximageversion desc, isvd.islinked, isvd.imagesetid
10392 "
10393
10394 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
10395 $cmd.Parameters["@imageid"].Value = $imageId
10396
10397 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
10398 $cmd.Parameters["@imagesetid"].Value = $imageSet.ImageSetId
10399
10400 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10401 $cmd = (ConvertTo-OracleCommand $cmd)
10402 }
10403
10404 $cmd.Connection = $dbConn
10405 $reader = $cmd.ExecuteReader()
10406
10407 $linkedImageSets = @()
10408
10409 while ($reader.Read()) {
10410 $linkedImageSet = $global:blankLinkedImageSet.PSObject.Copy()
10411
10412 $linkedImageSet.ImageSetId = ConvertTo-PsType $reader[0]
10413 $linkedImageSet.IsLinked = ConvertTo-PsType $reader[1]
10414 $linkedImageSet.Owner = ConvertTo-PsType $reader[2]
10415 $linkedImageSet.MaxImageVersion = ConvertTo-PsType $reader[3]
10416
10417 $linkedImageSets += $linkedImageSet
10418 }
10419
10420 return ,$linkedImageSets # The comma ensures an array is returned even if there is only one element.
10421 }
10422 catch {
10423 throw ("Error in Select-LinkedImageSets: " + $error[0])
10424 }
10425 finally {
10426 if ($reader) {$reader.Close()}
10427 }
10428} # Select-LinkedImageSets
10429
10430
10431Function Save-MergedImageSet ($imageSet, $sites) {
10432 try {
10433 $siteQueue = New-Object System.Collections.Queue
10434
10435 $sites.Values | Sort-Object SiteId | ForEach-Object {$siteQueue.Enqueue($_)}
10436
10437 while ($siteQueue.Count -gt 0) {
10438 $site = $siteQueue.Dequeue()
10439
10440 Delete-TransferQueueByImageSet $imageSetId $site.DbConn
10441 Save-ImageSet $imageSet $site
10442 }
10443 }
10444 catch {
10445 throw ("Error in Save-MergedImageSet: " + $error[0])
10446 }
10447} # Save-MergedImageSet
10448
10449
10450Function Delete-TransferQueueByImageSet ($imageSetId, $dbConn) {
10451 try {
10452 $cmd = New-Object System.Data.SqlClient.SqlCommand
10453
10454 $cmd.CommandText = "
10455 delete from TransferQueue where fileid = @imagesetid and category = 1
10456 "
10457
10458 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
10459 $cmd.Parameters["@imagesetid"].Value = $imageSetId
10460
10461 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10462 $cmd = (ConvertTo-OracleCommand $cmd)
10463 }
10464
10465 $cmd.Connection = $dbConn
10466
10467 $cmd.ExecuteNonQuery() | Out-Null
10468 }
10469 catch {
10470 throw ("Error in Delete-TransferQueueByImageSet: " + $error[0])
10471 }
10472} # Delete-TransferQueueByImageSet
10473
10474
10475# If an imageset is owned by Sat2, but Sat1 knows about it, we need to save the owner in
10476# Sat1 as 0. This is why we make a copy named $localImageSet below.
10477Function Save-ImageSet ($imageSet, $site) {
10478 try {
10479 $localImageSet = $imageSet.PSObject.Copy()
10480
10481 if ($imageSet.Owner -ne $site.SiteId -and $site.SiteId -ne 0) {$localImageSet.Owner = 0}
10482
10483 if ($imageSet.BatchId) {$batch = Select-Batch $imageSet.BatchId $site.DbConn}
10484 if (!$batch) {$localImageSet.BatchId = $null}
10485
10486 $dbTran = $site.DbConn.BeginTransaction()
10487
10488 $recordsUpdated = Update-ImageSet $localImageSet $site.DbConn $dbTran
10489 if ($recordsUpdated -eq 0) {Insert-ImageSet $localImageSet $site.DbConn $dbTran}
10490
10491 $imageSet.Versions.Values | Sort-Object Version | ForEach-Object {
10492 $isv = $_
10493
10494 if ($imageSet.Owner -ne 0 -and $site.SiteId -eq 0 -and !$global:saveImagesToMaster) {$asDummy = $true}
10495 else {$asDummy = $false}
10496
10497 Save-ImageSetVersion $isv $site $asDummy $dbTran
10498 }
10499
10500 $dbTran.Commit()
10501 }
10502 catch {
10503 if ($dbTran.Connection) {$dbTran.Rollback()}
10504 throw ("Error in Save-ImageSet: " + $error[0])
10505 }
10506} # Save-ImageSet
10507
10508
10509Function Update-ImageSet ($imageSet, $dbConn, $dbTran) {
10510 try {
10511 $cmd = New-Object System.Data.SqlClient.SqlCommand
10512
10513 $cmd.CommandText = "
10514 update ImageSet
10515 set encryptionkey = @encryptionkey, currentversion = @currentversion, owner = @owner,
10516 lockedby = @lockedby, lockexpiration = @lockexpiration, dynamicversion = @dynamicversion,
10517 batchid = @batchid, lockdetails = @lockdetails
10518 where imagesetid = @imagesetid
10519 "
10520
10521 $cmd.Parameters.Add("@encryptionkey", [System.Data.SqlDbType]::VarChar) | Out-Null
10522 $cmd.Parameters["@encryptionkey"].Value = $imageSet.EncryptionKey
10523
10524 $cmd.Parameters.Add("@currentversion", [System.Data.SqlDbType]::Int) | Out-Null
10525 $cmd.Parameters["@currentversion"].Value = $imageSet.CurrentVersion
10526
10527 $cmd.Parameters.Add("@owner", [System.Data.SqlDbType]::Int) | Out-Null
10528 $cmd.Parameters["@owner"].Value = $imageSet.Owner
10529
10530 $cmd.Parameters.Add("@lockedby", [System.Data.SqlDbType]::Int) | Out-Null
10531 $cmd.Parameters["@lockedby"].Value = ConvertTo-DbNull $imageSet.LockedBy
10532
10533 $cmd.Parameters.Add("@lockexpiration", [System.Data.SqlDbType]::DateTime) | Out-Null
10534 $cmd.Parameters["@lockexpiration"].Value = ConvertTo-DbNull $imageSet.LockExpiration
10535
10536 $cmd.Parameters.Add("@dynamicversion", [System.Data.SqlDbType]::Int) | Out-Null
10537 $cmd.Parameters["@dynamicversion"].Value = ConvertTo-DbNull $imageSet.DynamicVersion
10538
10539 $cmd.Parameters.Add("@batchid", [System.Data.SqlDbType]::Int) | Out-Null
10540 $cmd.Parameters["@batchid"].Value = ConvertTo-DbNull $imageSet.BatchId
10541
10542 $cmd.Parameters.Add("@lockdetails", [System.Data.SqlDbType]::Int) | Out-Null
10543 $cmd.Parameters["@lockdetails"].Value = ConvertTo-DbNull $imageSet.LockDetails
10544
10545 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
10546 $cmd.Parameters["@imagesetid"].Value = $imageSet.ImageSetId
10547
10548 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10549 $cmd = (ConvertTo-OracleCommand $cmd)
10550
10551 if ($imageSet.EncryptionKey -eq "") {$cmd.Parameters["@encryptionkey"].Value = " "}
10552 }
10553
10554 $cmd.Connection = $dbConn
10555 $cmd.Transaction = $dbTran
10556
10557 $rowsAffected = $cmd.ExecuteNonQuery()
10558
10559 return $rowsAffected
10560 }
10561 catch {
10562 throw ("Error in Update-ImageSet: " + $error[0])
10563 }
10564} # Update-ImageSet
10565
10566
10567Function Insert-ImageSet ($imageSet, $dbConn, $dbTran) {
10568 try {
10569 $cmd = New-Object System.Data.SqlClient.SqlCommand
10570
10571 $cmd.CommandText = "
10572 insert into ImageSet (
10573 imagesetid, encryptionkey, currentversion, owner, lockedby, lockexpiration,
10574 dynamicversion, batchid, lockdetails
10575 )
10576 values (
10577 @imagesetid, @encryptionkey, @currentversion, @owner, @lockedby, @lockexpiration,
10578 @dynamicversion, @batchid, @lockdetails
10579 )
10580 "
10581
10582 $cmd.Parameters.Add("@encryptionkey", [System.Data.SqlDbType]::VarChar) | Out-Null
10583 $cmd.Parameters["@encryptionkey"].Value = $imageSet.EncryptionKey
10584
10585 $cmd.Parameters.Add("@currentversion", [System.Data.SqlDbType]::Int) | Out-Null
10586 $cmd.Parameters["@currentversion"].Value = $imageSet.CurrentVersion
10587
10588 $cmd.Parameters.Add("@owner", [System.Data.SqlDbType]::Int) | Out-Null
10589 $cmd.Parameters["@owner"].Value = $imageSet.Owner
10590
10591 $cmd.Parameters.Add("@lockedby", [System.Data.SqlDbType]::Int) | Out-Null
10592 $cmd.Parameters["@lockedby"].Value = ConvertTo-DbNull $imageSet.LockedBy
10593
10594 $cmd.Parameters.Add("@lockexpiration", [System.Data.SqlDbType]::DateTime) | Out-Null
10595 $cmd.Parameters["@lockexpiration"].Value = ConvertTo-DbNull $imageSet.LockExpiration
10596
10597 $cmd.Parameters.Add("@dynamicversion", [System.Data.SqlDbType]::Int) | Out-Null
10598 $cmd.Parameters["@dynamicversion"].Value = ConvertTo-DbNull $imageSet.DynamicVersion
10599
10600 $cmd.Parameters.Add("@batchid", [System.Data.SqlDbType]::Int) | Out-Null
10601 $cmd.Parameters["@batchid"].Value = ConvertTo-DbNull $imageSet.BatchId
10602
10603 $cmd.Parameters.Add("@lockdetails", [System.Data.SqlDbType]::Int) | Out-Null
10604 $cmd.Parameters["@lockdetails"].Value = ConvertTo-DbNull $imageSet.LockDetails
10605
10606 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
10607 $cmd.Parameters["@imagesetid"].Value = $imageSet.ImageSetId
10608
10609 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10610 $cmd = (ConvertTo-OracleCommand $cmd)
10611
10612 if ($imageSet.EncryptionKey -eq "") {$cmd.Parameters["@encryptionkey"].Value = " "}
10613 }
10614
10615 $cmd.Connection = $dbConn
10616 $cmd.Transaction = $dbTran
10617
10618 $cmd.ExecuteNonQuery() | Out-Null
10619 }
10620 catch {
10621 throw ("Error in Insert-ImageSet: " + $error[0])
10622 }
10623} # Insert-ImageSet
10624
10625
10626Function Save-ImageSetVersion ($isv, $site, $asDummy, $dbTran) {
10627 try {
10628 $recordsUpdated = Update-ImageSetVersion $isv $site.DbConn $dbTran
10629 if ($recordsUpdated -eq 0) {Insert-ImageSetVersion $isv $site.DbConn $dbTran}
10630
10631 if ($isv.Image -ne $null) {
10632 Save-ImageSetVersionData $isv.ImageSetId $isv.Version $isv.Image $site $asDummy $dbTran
10633 }
10634
10635 if ($isv.Annotation -ne $null) {
10636 Save-ImageSetVersionData $isv.ImageSetId $isv.Version $isv.Annotation $site $asDummy $dbTran
10637 }
10638 }
10639 catch {
10640 throw ("Error in Save-ImageSetVersion: " + $error[0])
10641 }
10642} # Save-ImageSetVersion
10643
10644
10645Function Update-ImageSetVersion ($isv, $dbConn, $dbTran) {
10646 try {
10647 $cmd = New-Object System.Data.SqlClient.SqlCommand
10648
10649 $cmd.CommandText = "
10650 update ImageSetVersions
10651 set accountid = @accountid, datechanged = @datechanged
10652 where imagesetid = @imagesetid
10653 and imagesetversion = @imagesetversion
10654 "
10655
10656 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
10657 $cmd.Parameters["@imagesetid"].Value = $isv.ImageSetId
10658
10659 $cmd.Parameters.Add("@imagesetversion", [System.Data.SqlDbType]::Int) | Out-Null
10660 $cmd.Parameters["@imagesetversion"].Value = $isv.Version
10661
10662 $cmd.Parameters.Add("@accountid", [System.Data.SqlDbType]::Int) | Out-Null
10663 $cmd.Parameters["@accountid"].Value = $isv.AccountId
10664
10665 $cmd.Parameters.Add("@datechanged", [System.Data.SqlDbType]::DateTime) | Out-Null
10666 $cmd.Parameters["@datechanged"].Value = $isv.DateChanged
10667
10668 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10669 $cmd = (ConvertTo-OracleCommand $cmd)
10670 }
10671
10672 $cmd.Connection = $dbConn
10673 $cmd.Transaction = $dbTran
10674
10675 $rowsAffected = $cmd.ExecuteNonQuery()
10676
10677 return $rowsAffected
10678 }
10679 catch {
10680 throw ("Error in Update-ImageSetVersion: " + $error[0])
10681 }
10682} # Update-ImageSetVersion
10683
10684
10685Function Insert-ImageSetVersion ($isv, $dbConn, $dbTran) {
10686 try {
10687 $cmd = New-Object System.Data.SqlClient.SqlCommand
10688
10689 $cmd.CommandText = "
10690 insert into ImageSetVersions (imagesetid, imagesetversion, accountid, datechanged)
10691 values (@imagesetid, @imagesetversion, @accountid, @datechanged)
10692 "
10693
10694 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
10695 $cmd.Parameters["@imagesetid"].Value = $isv.ImageSetId
10696
10697 $cmd.Parameters.Add("@imagesetversion", [System.Data.SqlDbType]::Int) | Out-Null
10698 $cmd.Parameters["@imagesetversion"].Value = $isv.Version
10699
10700 $cmd.Parameters.Add("@accountid", [System.Data.SqlDbType]::Int) | Out-Null
10701 $cmd.Parameters["@accountid"].Value = $isv.AccountId
10702
10703 $cmd.Parameters.Add("@datechanged", [System.Data.SqlDbType]::DateTime) | Out-Null
10704 $cmd.Parameters["@datechanged"].Value = $isv.DateChanged
10705
10706 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10707 $cmd = (ConvertTo-OracleCommand $cmd)
10708 }
10709
10710 $cmd.Connection = $dbConn
10711 $cmd.Transaction = $dbTran
10712
10713 $cmd.ExecuteNonQuery() | Out-Null
10714 }
10715 catch {
10716 throw ("Error in Insert-ImageSetVersion: " + $error[0])
10717 }
10718} # Insert-ImageSetVersion
10719
10720
10721# Create blank object once, so it can be copied to create new instances.
10722# This results in huge performance gains.
10723$global:blankIsvd = New-Object PSObject
10724$global:blankIsvd | Add-Member NoteProperty ImageSetId $null
10725$global:blankIsvd | Add-Member NoteProperty ImageSetVersion $null
10726$global:blankIsvd | Add-Member NoteProperty ImageId $null
10727$global:blankIsvd | Add-Member NoteProperty ImageVersion $null
10728$global:blankIsvd | Add-Member NoteProperty IsLinked $null
10729$global:blankIsvd | Add-Member NoteProperty ImageType $null
10730
10731Function Save-ImageSetVersionData ($imageSetId, $imageSetVersion, $image, $site, $asDummy, $dbTran) {
10732 try {
10733 Save-Image $image $site $asDummy $dbTran
10734
10735 $isvd = $global:blankIsvd.PSObject.Copy()
10736 $isvd.ImageSetId = $imageSetId
10737 $isvd.ImageSetVersion = $imageSetVersion
10738 $isvd.ImageId = $image.ImageId
10739 $isvd.ImageVersion = $image.Version
10740 $isvd.IsLinked = $image.IsLinked
10741 $isvd.ImageType = $image.ImageType
10742
10743 Delete-ImageSetVersionData $isvd $site.DbConn $dbTran
10744 Insert-ImageSetVersionData $isvd $site.DbConn $dbTran
10745 }
10746 catch {
10747 throw ("Error in Save-ImageSetVersionData: " + $error[0])
10748 }
10749} # Save-ImageSetVersionData
10750
10751
10752Function Save-Image ($image, $site, $asDummy, $dbTran) {
10753 try {
10754 $cacheOk = $false
10755 $siteImage = Get-Image $image.ImageId $image.Version $null $site $cacheOk $dbTran
10756
10757 if ($siteImage -eq $null -or $siteImage.ImageFile -eq $null) {
10758 if ($asDummy -eq $true) {
10759 $image = New-DummyImage $image
10760 }
10761 else {
10762 $defaultPrimary = $site.Devices | Where-Object {$_.IsDefault -eq 1}
10763
10764 $image.OnlineDevice = $null
10765 $image.NearlineDevice = $defaultPrimary.DeviceId
10766 $image.Critical = 0
10767 $image.PathDate = $site.ActiveImagePath.PathDate
10768 $image.DivisionNumber = $site.ActiveImagePath.DivisionNumber
10769
10770 $newImagePath = Get-ImagePath $image $defaultPrimary
10771
10772 Copy-Item $image.ImageFile $newImagePath
10773
10774 $global:sites[$site.SiteId].ActiveImagePath.ImageCount++
10775 }
10776 }
10777 else {
10778 $image.OnlineDevice = $siteImage.OnlineDevice
10779 $image.NearlineDevice = $siteImage.NearlineDevice
10780 $image.Critical = $siteImage.Critical
10781 $image.PathDate = $siteImage.PathDate
10782 $image.DivisionNumber = $siteImage.DivisionNumber
10783 }
10784
10785 $image.SiteId = $site.SiteId
10786
10787 $rowsUpdated = Update-ImageVersion $image $site.DbConn $dbTran
10788 if ($rowsUpdated -eq 0) {Insert-ImageVersion $image $site.DbConn $dbTran}
10789
10790 $rowsUpdated = Update-Image $image $site.DbConn $dbTran
10791 if ($rowsUpdated -eq 0) {Insert-Image $image $site.DbConn $dbTran}
10792 }
10793 catch {
10794 throw ("Error in Save-Image: " + $error[0])
10795 }
10796} # Save-Image
10797
10798
10799Function New-DummyImage ($image) {
10800 try {
10801 $dummyImage = $global:blankImage.PSObject.Copy()
10802
10803 $dummyImage.ImageId = $image.ImageId
10804 $dummyImage.Version = $image.Version
10805 $dummyImage.VersionCreated = $image.VersionCreated
10806 $dummyImage.DateAccessed = $image.DateAccessed
10807 $dummyImage.DivisionNumber = 0
10808 $dummyImage.Critical = 0
10809 $dummyImage.PathDate = 0
10810 $dummyImage.SiteId = $image.SiteId
10811 $dummyImage.ArchiveImmediate = 0
10812 $dummyImage.FileSize = 0
10813 $dummyImage.Rotation = 0
10814 $dummyImage.PreRotation = 0
10815 $dummyImage.ContentType = 0
10816 $dummyImage.Status = 0
10817 $dummyImage.CurrentVersion = $image.CurrentVersion
10818 $dummyImage.ImageCreated = $image.ImageCreated
10819 $dummyImage.DynamicVersion = $image.DynamicVersion
10820 $dummyImage.Extension = $image.Extension
10821 $dummyImage.ImageType = $image.ImageType
10822
10823 return $dummyImage
10824 }
10825 catch {
10826 throw ("Error in New-DummyImage " + $error[0])
10827 }
10828} # New-DummyImage
10829
10830
10831Function Update-ImageVersion ($image, $dbConn, $dbTran) {
10832 try {
10833 $cmd = New-Object System.Data.SqlClient.SqlCommand
10834
10835 $cmd.CommandText = "
10836 update ImageVersion
10837 set datecreated = @datecreated, dateaccessed = @dateaccessed, divisionnumber = @divisionnumber,
10838 onlinedevice = @onlinedevice, nearlinedevice = @nearlinedevice, encrypted = @encrypted,
10839 critical = @critical, pathdate = @pathdate, siteid = @siteid,
10840 archiveimmediate = @archiveimmediate, deferstatic = @deferstatic, filesize = @filesize,
10841 rotation = @rotation, prerotation = @prerotation, contenttype = @contenttype,
10842 status = @status, md5a = @md5a, md5b = @md5b
10843 where imageid = @imageid
10844 and imageversion = @imageversion
10845 "
10846
10847 $cmd.Parameters.Add("@datecreated", [System.Data.SqlDbType]::DateTime) | Out-Null
10848 $cmd.Parameters["@datecreated"].Value = $image.VersionCreated
10849
10850 $cmd.Parameters.Add("@dateaccessed", [System.Data.SqlDbType]::DateTime) | Out-Null
10851 $cmd.Parameters["@dateaccessed"].Value = $image.DateAccessed
10852
10853 $cmd.Parameters.Add("@divisionnumber", [System.Data.SqlDbType]::Int) | Out-Null
10854 $cmd.Parameters["@divisionnumber"].Value = $image.DivisionNumber
10855
10856 $cmd.Parameters.Add("@onlinedevice", [System.Data.SqlDbType]::Int) | Out-Null
10857 $cmd.Parameters["@onlinedevice"].Value = ConvertTo-DbNull $image.OnlineDevice
10858
10859 $cmd.Parameters.Add("@nearlinedevice", [System.Data.SqlDbType]::Int) | Out-Null
10860 $cmd.Parameters["@nearlinedevice"].Value = ConvertTo-DbNull $image.NearlineDevice
10861
10862 $cmd.Parameters.Add("@encrypted", [System.Data.SqlDbType]::Int) | Out-Null
10863 $cmd.Parameters["@encrypted"].Value = ConvertTo-DbNull $image.Encrypted
10864
10865 $cmd.Parameters.Add("@critical", [System.Data.SqlDbType]::Int) | Out-Null
10866 $cmd.Parameters["@critical"].Value = $image.Critical
10867
10868 $cmd.Parameters.Add("@pathdate", [System.Data.SqlDbType]::Int) | Out-Null
10869 $cmd.Parameters["@pathdate"].Value = $image.PathDate
10870
10871 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
10872 $cmd.Parameters["@siteid"].Value = $image.SiteId
10873
10874 $cmd.Parameters.Add("@archiveimmediate", [System.Data.SqlDbType]::Int) | Out-Null
10875 $cmd.Parameters["@archiveimmediate"].Value = $image.ArchiveImmediate
10876
10877 $cmd.Parameters.Add("@deferstatic", [System.Data.SqlDbType]::Int) | Out-Null
10878 $cmd.Parameters["@deferstatic"].Value = ConvertTo-DbNull $image.DeferStatic
10879
10880 $cmd.Parameters.Add("@filesize", [System.Data.SqlDbType]::BigInt) | Out-Null
10881 $cmd.Parameters["@filesize"].Value = $image.FileSize
10882
10883 $cmd.Parameters.Add("@rotation", [System.Data.SqlDbType]::Int) | Out-Null
10884 $cmd.Parameters["@rotation"].Value = $image.Rotation
10885
10886 $cmd.Parameters.Add("@prerotation", [System.Data.SqlDbType]::Int) | Out-Null
10887 $cmd.Parameters["@prerotation"].Value = $image.PreRotation
10888
10889 $cmd.Parameters.Add("@contenttype", [System.Data.SqlDbType]::Int) | Out-Null
10890 $cmd.Parameters["@contenttype"].Value = $image.ContentType
10891
10892 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::Int) | Out-Null
10893 $cmd.Parameters["@status"].Value = $image.Status
10894
10895 $cmd.Parameters.Add("@md5a", [System.Data.SqlDbType]::BigInt) | Out-Null
10896 $cmd.Parameters["@md5a"].Value = ConvertTo-DbNull $image.Md5a
10897
10898 $cmd.Parameters.Add("@md5b", [System.Data.SqlDbType]::BigInt) | Out-Null
10899 $cmd.Parameters["@md5b"].Value = ConvertTo-DbNull $image.Md5b
10900
10901 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
10902 $cmd.Parameters["@imageid"].Value = $image.ImageId
10903
10904 $cmd.Parameters.Add("@imageversion", [System.Data.SqlDbType]::Int) | Out-Null
10905 $cmd.Parameters["@imageversion"].Value = $image.Version
10906
10907 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
10908 $cmd = (ConvertTo-OracleCommand $cmd)
10909 }
10910
10911 $cmd.Connection = $dbConn
10912 $cmd.Transaction = $dbTran
10913
10914 $rowsAffected = $cmd.ExecuteNonQuery()
10915
10916 return $rowsAffected
10917 }
10918 catch {
10919 throw ("Error in Update-ImageVersion: " + $error[0])
10920 }
10921} # Update-ImageVersion
10922
10923
10924Function Insert-ImageVersion ($image, $dbConn, $dbTran) {
10925 try {
10926 $cmd = New-Object System.Data.SqlClient.SqlCommand
10927
10928 $cmd.CommandText = "
10929 insert into ImageVersion (
10930 imageid, datecreated, dateaccessed, imageversion, divisionnumber, onlinedevice,
10931 nearlinedevice, encrypted, critical, pathdate, siteid, archiveimmediate,
10932 deferstatic, filesize, rotation, prerotation, contenttype, status, md5a, md5b
10933 )
10934 values (
10935 @imageid, @datecreated, @dateaccessed, @imageversion, @divisionnumber, @onlinedevice,
10936 @nearlinedevice, @encrypted, @critical, @pathdate, @siteid, @archiveimmediate,
10937 @deferstatic, @filesize, @rotation, @prerotation, @contenttype, @status, @md5a, @md5b
10938 )
10939 "
10940
10941 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
10942 $cmd.Parameters["@imageid"].Value = $image.ImageId
10943
10944 $cmd.Parameters.Add("@datecreated", [System.Data.SqlDbType]::DateTime) | Out-Null
10945 $cmd.Parameters["@datecreated"].Value = $image.VersionCreated
10946
10947 $cmd.Parameters.Add("@dateaccessed", [System.Data.SqlDbType]::DateTime) | Out-Null
10948 $cmd.Parameters["@dateaccessed"].Value = $image.DateAccessed
10949
10950 $cmd.Parameters.Add("@imageversion", [System.Data.SqlDbType]::Int) | Out-Null
10951 $cmd.Parameters["@imageversion"].Value = $image.Version
10952
10953 $cmd.Parameters.Add("@divisionnumber", [System.Data.SqlDbType]::Int) | Out-Null
10954 $cmd.Parameters["@divisionnumber"].Value = $image.DivisionNumber
10955
10956 $cmd.Parameters.Add("@onlinedevice", [System.Data.SqlDbType]::Int) | Out-Null
10957 $cmd.Parameters["@onlinedevice"].Value = ConvertTo-DbNull $image.OnlineDevice
10958
10959 $cmd.Parameters.Add("@nearlinedevice", [System.Data.SqlDbType]::Int) | Out-Null
10960 $cmd.Parameters["@nearlinedevice"].Value = ConvertTo-DbNull $image.NearlineDevice
10961
10962 $cmd.Parameters.Add("@encrypted", [System.Data.SqlDbType]::Int) | Out-Null
10963 $cmd.Parameters["@encrypted"].Value = ConvertTo-DbNull $image.Encrypted
10964
10965 $cmd.Parameters.Add("@critical", [System.Data.SqlDbType]::Int) | Out-Null
10966 $cmd.Parameters["@critical"].Value = $image.Critical
10967
10968 $cmd.Parameters.Add("@pathdate", [System.Data.SqlDbType]::Int) | Out-Null
10969 $cmd.Parameters["@pathdate"].Value = $image.PathDate
10970
10971 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
10972 $cmd.Parameters["@siteid"].Value = $image.SiteId
10973
10974 $cmd.Parameters.Add("@archiveimmediate", [System.Data.SqlDbType]::Int) | Out-Null
10975 $cmd.Parameters["@archiveimmediate"].Value = $image.ArchiveImmediate
10976
10977 $cmd.Parameters.Add("@deferstatic", [System.Data.SqlDbType]::Int) | Out-Null
10978 $cmd.Parameters["@deferstatic"].Value = ConvertTo-DbNull $image.DeferStatic
10979
10980 $cmd.Parameters.Add("@filesize", [System.Data.SqlDbType]::BigInt) | Out-Null
10981 $cmd.Parameters["@filesize"].Value = $image.FileSize
10982
10983 $cmd.Parameters.Add("@rotation", [System.Data.SqlDbType]::Int) | Out-Null
10984 $cmd.Parameters["@rotation"].Value = $image.Rotation
10985
10986 $cmd.Parameters.Add("@prerotation", [System.Data.SqlDbType]::Int) | Out-Null
10987 $cmd.Parameters["@prerotation"].Value = $image.PreRotation
10988
10989 $cmd.Parameters.Add("@contenttype", [System.Data.SqlDbType]::Int) | Out-Null
10990 $cmd.Parameters["@contenttype"].Value = $image.ContentType
10991
10992 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::Int) | Out-Null
10993 $cmd.Parameters["@status"].Value = $image.Status
10994
10995 $cmd.Parameters.Add("@md5a", [System.Data.SqlDbType]::BigInt) | Out-Null
10996 $cmd.Parameters["@md5a"].Value = ConvertTo-DbNull $image.Md5a
10997
10998 $cmd.Parameters.Add("@md5b", [System.Data.SqlDbType]::BigInt) | Out-Null
10999 $cmd.Parameters["@md5b"].Value = ConvertTo-DbNull $image.Md5b
11000
11001 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11002 $cmd = (ConvertTo-OracleCommand $cmd)
11003 }
11004
11005 $cmd.Connection = $dbConn
11006 $cmd.Transaction = $dbTran
11007
11008 $cmd.ExecuteNonQuery() | Out-Null
11009 }
11010 catch {
11011 throw ("Error in Insert-ImageVersion: " + $error[0])
11012 }
11013} # Insert-ImageVersion
11014
11015
11016Function Update-Image ($image, $dbConn, $dbTran) {
11017 try {
11018 $cmd = New-Object System.Data.SqlClient.SqlCommand
11019
11020 $cmd.CommandText = "
11021 update Image
11022 set currentversion = @currentversion, datecreated = @datecreated,
11023 dynamicversion = @dynamicversion, ext = @extension, type = @type
11024 where imageid = @imageid
11025 "
11026
11027 $cmd.Parameters.Add("@currentversion", [System.Data.SqlDbType]::Int) | Out-Null
11028 $cmd.Parameters["@currentversion"].Value = $image.CurrentVersion
11029
11030 $cmd.Parameters.Add("@datecreated", [System.Data.SqlDbType]::DateTime) | Out-Null
11031 $cmd.Parameters["@datecreated"].Value = $image.ImageCreated
11032
11033 $cmd.Parameters.Add("@dynamicversion", [System.Data.SqlDbType]::Int) | Out-Null
11034 $cmd.Parameters["@dynamicversion"].Value = ConvertTo-DbNull $image.DynamicVersion
11035
11036 $cmd.Parameters.Add("@extension", [System.Data.SqlDbType]::VarChar) | Out-Null
11037 $cmd.Parameters["@extension"].Value = $image.Extension
11038
11039 $cmd.Parameters.Add("@type", [System.Data.SqlDbType]::Int) | Out-Null
11040 $cmd.Parameters["@type"].Value = $image.ImageType
11041
11042 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
11043 $cmd.Parameters["@imageid"].Value = $image.ImageId
11044
11045 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11046 $cmd = (ConvertTo-OracleCommand $cmd)
11047 }
11048
11049 $cmd.Connection = $dbConn
11050 $cmd.Transaction = $dbTran
11051
11052 $rowsAffected = $cmd.ExecuteNonQuery()
11053
11054 return $rowsAffected
11055 }
11056 catch {
11057 throw ("Error in Update-Image: " + $error[0])
11058 }
11059} # Update-Image
11060
11061
11062Function Insert-Image ($image, $dbConn, $dbTran) {
11063 try {
11064 $cmd = New-Object System.Data.SqlClient.SqlCommand
11065
11066 $cmd.CommandText = "
11067 insert into Image (imageid, currentversion, datecreated, dynamicversion, ext, type)
11068 values (@imageid, @currentversion, @datecreated, @dynamicversion, @extension, @type)
11069 "
11070
11071 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
11072 $cmd.Parameters["@imageid"].Value = $image.ImageId
11073
11074 $cmd.Parameters.Add("@currentversion", [System.Data.SqlDbType]::Int) | Out-Null
11075 $cmd.Parameters["@currentversion"].Value = $image.CurrentVersion
11076
11077 $cmd.Parameters.Add("@datecreated", [System.Data.SqlDbType]::DateTime) | Out-Null
11078 $cmd.Parameters["@datecreated"].Value = $image.ImageCreated
11079
11080 $cmd.Parameters.Add("@dynamicversion", [System.Data.SqlDbType]::Int) | Out-Null
11081 $cmd.Parameters["@dynamicversion"].Value = ConvertTo-DbNull $image.DynamicVersion
11082
11083 $cmd.Parameters.Add("@extension", [System.Data.SqlDbType]::VarChar) | Out-Null
11084 $cmd.Parameters["@extension"].Value = $image.Extension
11085
11086 $cmd.Parameters.Add("@type", [System.Data.SqlDbType]::Int) | Out-Null
11087 $cmd.Parameters["@type"].Value = $image.ImageType
11088
11089 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11090 $cmd = (ConvertTo-OracleCommand $cmd)
11091 }
11092
11093 $cmd.Connection = $dbConn
11094 $cmd.Transaction = $dbTran
11095
11096 $cmd.ExecuteNonQuery() | Out-Null
11097 }
11098 catch {
11099 throw ("Error in Insert-Image: " + $error[0])
11100 }
11101} # Insert-Image
11102
11103
11104Function Delete-ImageSetVersionData ($isvd, $dbConn, $dbTran) {
11105 try {
11106 $cmd = New-Object System.Data.SqlClient.SqlCommand
11107
11108 $cmd.CommandText = "
11109 delete from ImageSetVersionData
11110 where imagesetid = @imagesetid
11111 and imagesetversion = @imagesetversion
11112 and exists (
11113 select 1
11114 from Image
11115 where imageid = ImageSetVersionData.imageid
11116 and type = @type
11117 )
11118 "
11119
11120 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
11121 $cmd.Parameters["@imagesetid"].Value = $isvd.ImageSetId
11122
11123 $cmd.Parameters.Add("@imagesetversion", [System.Data.SqlDbType]::Int) | Out-Null
11124 $cmd.Parameters["@imagesetversion"].Value = $isvd.ImageSetVersion
11125
11126 $cmd.Parameters.Add("@type", [System.Data.SqlDbType]::Int) | Out-Null
11127 $cmd.Parameters["@type"].Value = $isvd.ImageType
11128
11129 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11130 $cmd = (ConvertTo-OracleCommand $cmd)
11131 }
11132
11133 $cmd.Connection = $dbConn
11134 $cmd.Transaction = $dbTran
11135
11136 $cmd.ExecuteNonQuery() | Out-Null
11137 }
11138 catch {
11139 throw ("Error in Delete-ImageSetVersionData: " + $error[0])
11140 }
11141} # Delete-ImageSetVersionData
11142
11143
11144Function Update-ImageSetVersionData ($isvd, $dbConn, $dbTran) {
11145 try {
11146 $cmd = New-Object System.Data.SqlClient.SqlCommand
11147
11148 $cmd.CommandText = "
11149 update ImageSetVersionData
11150 set imageid = @imageid, imageversion = @imageversion, islinked = @islinked
11151 where imagesetid = @imagesetid
11152 and imagesetversion = @imagesetversion
11153 and exists (
11154 select 1
11155 from Image
11156 where imageid = ImageSetVersionData.imageid
11157 and type = @type
11158 )
11159 "
11160
11161 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
11162 $cmd.Parameters["@imageid"].Value = $isvd.ImageId
11163
11164 $cmd.Parameters.Add("@imageversion", [System.Data.SqlDbType]::Int) | Out-Null
11165 $cmd.Parameters["@imageversion"].Value = $isvd.ImageVersion
11166
11167 $cmd.Parameters.Add("@islinked", [System.Data.SqlDbType]::Int) | Out-Null
11168 $cmd.Parameters["@islinked"].Value = $isvd.IsLinked
11169
11170 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
11171 $cmd.Parameters["@imagesetid"].Value = $isvd.ImageSetId
11172
11173 $cmd.Parameters.Add("@imagesetversion", [System.Data.SqlDbType]::Int) | Out-Null
11174 $cmd.Parameters["@imagesetversion"].Value = $isvd.ImageSetVersion
11175
11176 $cmd.Parameters.Add("@type", [System.Data.SqlDbType]::Int) | Out-Null
11177 $cmd.Parameters["@type"].Value = $isvd.ImageType
11178
11179 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11180 $cmd = (ConvertTo-OracleCommand $cmd)
11181 }
11182
11183 $cmd.Connection = $dbConn
11184 $cmd.Transaction = $dbTran
11185
11186 $rowsAffected = $cmd.ExecuteNonQuery()
11187
11188 return $rowsAffected
11189 }
11190 catch {
11191 throw ("Error in Update-ImageSetVersionData: " + $error[0])
11192 }
11193} # Update-ImageSetVersionData
11194
11195
11196Function Insert-ImageSetVersionData ($isvd, $dbConn, $dbTran) {
11197 try {
11198 $cmd = New-Object System.Data.SqlClient.SqlCommand
11199
11200 $cmd.CommandText = "
11201 insert into ImageSetVersionData (imagesetid, imagesetversion, imageid, imageversion, islinked)
11202 values (@imagesetid, @imagesetversion, @imageid, @imageversion, @islinked)
11203 "
11204
11205 $cmd.Parameters.Add("@imagesetid", [System.Data.SqlDbType]::Int) | Out-Null
11206 $cmd.Parameters["@imagesetid"].Value = $isvd.ImageSetId
11207
11208 $cmd.Parameters.Add("@imagesetversion", [System.Data.SqlDbType]::Int) | Out-Null
11209 $cmd.Parameters["@imagesetversion"].Value = $isvd.ImageSetVersion
11210
11211 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
11212 $cmd.Parameters["@imageid"].Value = $isvd.ImageId
11213
11214 $cmd.Parameters.Add("@imageversion", [System.Data.SqlDbType]::Int) | Out-Null
11215 $cmd.Parameters["@imageversion"].Value = $isvd.ImageVersion
11216
11217 $cmd.Parameters.Add("@islinked", [System.Data.SqlDbType]::Int) | Out-Null
11218 $cmd.Parameters["@islinked"].Value = $isvd.IsLinked
11219
11220 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11221 $cmd = (ConvertTo-OracleCommand $cmd)
11222 }
11223
11224 $cmd.Connection = $dbConn
11225 $cmd.Transaction = $dbTran
11226
11227 $cmd.ExecuteNonQuery() | Out-Null
11228 }
11229 catch {
11230 throw ("Error in Insert-ImageSetVersionData: " + $error[0])
11231 }
11232} # Insert-ImageSetVersionData
11233
11234
11235$global:diffQueries["ObjectLink_MasterNotAtSat"] = "
11236 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
11237 select @satelliteid, 'ObjectLink', ol_mast.objectid, null, 'Unprocessed', @statustime
11238 from {MasterPrefix}ObjectLink{MasterSuffix} ol_mast
11239 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = ol_mast.objectid
11240 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = ol_mast.objectid
11241 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
11242 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid)
11243 and not exists (
11244 select 1
11245 from {SatellitePrefix}ObjectLink{SatelliteSuffix}
11246 where objectid = ol_mast.objectid
11247 )
11248"
11249
11250$global:diffQueries["ObjectLink_SatNotAtMaster"] = "
11251 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
11252 select @satelliteid, 'ObjectLink', ol_sat.objectid, null, 'Unprocessed', @statustime
11253 from {SatellitePrefix}ObjectLink{SatelliteSuffix} ol_sat
11254 where not exists (
11255 select 1
11256 from {MasterPrefix}ObjectLink{MasterSuffix}
11257 where objectid = ol_sat.objectid
11258 )
11259"
11260
11261$global:diffQueries["ObjectLink_MasterSatDiff"] = "
11262 insert into SyncIssue (siteid, type, itemid, itemid2, status, statustime)
11263 select @satelliteid, 'ObjectLink', ol_mast.objectid, null, 'Unprocessed', @statustime
11264 from {MasterPrefix}ObjectLink{MasterSuffix} ol_mast
11265 left join {MasterPrefix}Files{MasterSuffix} f_mast on f_mast.fileid = ol_mast.objectid
11266 left join {MasterPrefix}DocFolder{MasterSuffix} df_mast on df_mast.docfolderid = ol_mast.objectid
11267 left join {MasterPrefix}Files{MasterSuffix} fdf_mast on fdf_mast.fileid = df_mast.fileid
11268 join {SatellitePrefix}ObjectLink{SatelliteSuffix} ol_sat on ol_sat.objectid = ol_mast.objectid
11269 left join {SatellitePrefix}Files{SatelliteSuffix} f_sat on f_sat.fileid = ol_sat.objectid
11270 left join {SatellitePrefix}DocFolder{SatelliteSuffix} df_sat on df_sat.docfolderid = ol_sat.objectid
11271 left join {SatellitePrefix}Files{SatelliteSuffix} fdf_sat on fdf_sat.fileid = df_sat.fileid
11272 where (f_mast.owner = @satelliteid or fdf_mast.owner = @satelliteid or f_sat.owner = @satelliteid or fdf_sat.owner = @satelliteid)
11273 and ol_mast.typeid <> ol_sat.typeid
11274"
11275
11276
11277Function Merge-ObjectLink ($objectLink1, $objectLink2) {
11278 try {
11279 return $objectLink1
11280 }
11281 catch {
11282 throw ("Error in Merge-ObjectLink: " + $error[0])
11283 }
11284} # Merge-ObjectLink
11285
11286
11287# Create blank object once, so it can be copied to create new instances.
11288# This results in huge performance gains.
11289$global:blankObjectLink = $global:blankItem.PSObject.Copy()
11290$global:blankObjectLink.ItemType = "ObjectLink"
11291$global:blankObjectLink | Add-Member NoteProperty TypeId $null
11292
11293Function Select-ObjectLink ($objectId, $dbConn) {
11294 try {
11295 $cmd = New-Object System.Data.SqlClient.SqlCommand
11296
11297 $cmd.CommandText = "
11298 select case when f.owner is null then fdf.owner else f.owner end owner, ol.typeid
11299 from ObjectLink ol
11300 left join Files f on f.fileid = ol.objectid
11301 left join DocFolder df on df.docfolderid = ol.objectid
11302 left join Files fdf on fdf.fileid = df.fileid
11303 where ol.objectid = @objectid
11304 "
11305
11306 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
11307 $cmd.Parameters["@objectid"].Value = $objectId
11308
11309 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11310 $cmd = (ConvertTo-OracleCommand $cmd)
11311 }
11312
11313 $cmd.Connection = $dbConn
11314
11315 $reader = $cmd.ExecuteReader()
11316
11317 if ($reader.Read()) {
11318 $objectLink = $global:blankObjectLink.PSObject.Copy()
11319
11320 $objectLink.ItemId = $objectId
11321 $objectLink.ItemId2 = $null
11322 $objectLink.Owner = ConvertTo-PsType $reader[0]
11323 $objectLink.TypeId = ConvertTo-PsType $reader[1]
11324 }
11325 else {
11326 $objectLink = $null
11327 }
11328
11329 return $objectLink
11330 }
11331 catch {
11332 throw ("Error in Select-ObjectLink: " + $error[0])
11333 }
11334 finally {
11335 if ($reader) {$reader.Close()}
11336 }
11337} # Select-ObjectLink
11338
11339
11340Function Update-ObjectLink ($objectLink, $dbConn) {
11341 try {
11342 $cmd = New-Object System.Data.SqlClient.SqlCommand
11343
11344 $cmd.CommandText = "
11345 update ObjectLink
11346 set typeid = @typeid
11347 where objectid = @objectid
11348 "
11349
11350 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
11351 $cmd.Parameters["@objectid"].Value = $objectLink.ItemId
11352
11353 $cmd.Parameters.Add("@typeid", [System.Data.SqlDbType]::Int) | Out-Null
11354 $cmd.Parameters["@typeid"].Value = $objectLink.TypeId
11355
11356 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11357 $cmd = (ConvertTo-OracleCommand $cmd)
11358 }
11359
11360 $cmd.Connection = $dbConn
11361
11362 $rowsAffected = $cmd.ExecuteNonQuery()
11363
11364 return $rowsAffected
11365 }
11366 catch {
11367 throw ("Error in Update-ObjectLink: " + $error[0])
11368 }
11369} # Update-ObjectLink
11370
11371
11372Function Insert-ObjectLink ($objectLink, $dbConn) {
11373 try {
11374 $cmd = New-Object System.Data.SqlClient.SqlCommand
11375
11376 $cmd.CommandText = "
11377 insert into ObjectLink (objectid, typeid)
11378 values (@objectid, @typeid)
11379 "
11380
11381 $cmd.Parameters.Add("@objectid", [System.Data.SqlDbType]::Int) | Out-Null
11382 $cmd.Parameters["@objectid"].Value = $objectLink.ItemId
11383
11384 $cmd.Parameters.Add("@typeid", [System.Data.SqlDbType]::Int) | Out-Null
11385 $cmd.Parameters["@typeid"].Value = $objectLink.TypeId
11386
11387 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11388 $cmd = (ConvertTo-OracleCommand $cmd)
11389 }
11390
11391 $cmd.Connection = $dbConn
11392
11393 $rowsAffected = $cmd.ExecuteNonQuery()
11394
11395 return $rowsAffected
11396 }
11397 catch {
11398 throw ("Error in Insert-ObjectLink: " + $error[0])
11399 }
11400} # Insert-ObjectLink
11401
11402
11403Function Truncate-TracerImageLog ($dbConn) {
11404 try {
11405 $cmd = New-Object System.Data.SqlClient.SqlCommand
11406
11407 $cmd.CommandText = "truncate table TracerImageLog"
11408
11409 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11410 $cmd = (ConvertTo-OracleCommand $cmd)
11411 }
11412
11413 $cmd.Connection = $dbConn
11414
11415 $cmd.ExecuteNonQuery() | Out-Null
11416 }
11417 catch {
11418 throw ("Error in Truncate-TracerImageLog: " + $error[0])
11419 }
11420} # Truncate-TracerImageLog
11421
11422
11423Function Insert-TracerImageIgnore ($imageId, $imageVersion, $dbConn) {
11424 try {
11425 $cmd = New-Object System.Data.SqlClient.SqlCommand
11426
11427 $cmd.CommandText = "
11428 insert into TracerImageIgnore (imageid, imageversion)
11429 values (@imageid, @imageversion)
11430 "
11431
11432 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
11433 $cmd.Parameters["@imageid"].Value = $imageId
11434
11435 $cmd.Parameters.Add("@imageversion", [System.Data.SqlDbType]::Int) | Out-Null
11436 $cmd.Parameters["@imageversion"].Value = $imageVersion
11437
11438 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11439 $cmd = (ConvertTo-OracleCommand $cmd)
11440 }
11441
11442 $cmd.Connection = $dbConn
11443
11444 $cmd.ExecuteNonQuery() | Out-Null
11445 }
11446 catch {
11447 throw ("Error in Insert-TracerImageIgnore: " + $error[0])
11448 }
11449} # Insert-TracerImageIgnore
11450
11451
11452Function Insert-TracerImageLog ($imageId, $imageVersion, $dbConn) {
11453 try {
11454 $cmd = New-Object System.Data.SqlClient.SqlCommand
11455
11456 $cmd.CommandText = "
11457 insert into TracerImageLog (
11458 imageid, imageversion, pathtype, path, resultcode, tracetime, actualsize, expectedsize
11459 )
11460 values (
11461 @imageid, @imageversion, @pathtype, @path, @resultcode, @tracetime, @actualsize, @expectedsize
11462 )
11463 "
11464
11465 $cmd.Parameters.Add("@imageid", [System.Data.SqlDbType]::Int) | Out-Null
11466 $cmd.Parameters["@imageid"].Value = $imageId
11467
11468 $cmd.Parameters.Add("@imageversion", [System.Data.SqlDbType]::Int) | Out-Null
11469 $cmd.Parameters["@imageversion"].Value = $imageVersion
11470
11471 $cmd.Parameters.Add("@pathtype", [System.Data.SqlDbType]::Int) | Out-Null
11472 $cmd.Parameters["@pathtype"].Value = 0
11473
11474 $cmd.Parameters.Add("@path", [System.Data.SqlDbType]::VarChar) | Out-Null
11475 $cmd.Parameters["@path"].Value = " "
11476
11477 $cmd.Parameters.Add("@resultcode", [System.Data.SqlDbType]::Int) | Out-Null
11478 $cmd.Parameters["@resultcode"].Value = 1
11479
11480 $cmd.Parameters.Add("@tracetime", [System.Data.SqlDbType]::DateTime) | Out-Null
11481 $cmd.Parameters["@tracetime"].Value = (Get-Date)
11482
11483 $cmd.Parameters.Add("@actualsize", [System.Data.SqlDbType]::Int) | Out-Null
11484 $cmd.Parameters["@actualsize"].Value = 0
11485
11486 $cmd.Parameters.Add("@expectedsize", [System.Data.SqlDbType]::Int) | Out-Null
11487 $cmd.Parameters["@expectedsize"].Value = 0
11488
11489 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11490 $cmd = (ConvertTo-OracleCommand $cmd)
11491 }
11492
11493 $cmd.Connection = $dbConn
11494
11495 $cmd.ExecuteNonQuery() | Out-Null
11496 }
11497 catch {
11498 throw ("Error in Insert-TracerImageLog: " + $error[0])
11499 }
11500} # Insert-TracerImageLog
11501
11502
11503# Create blank object once, so it can be copied to create new instances.
11504# This results in huge performance gains.
11505$global:blankImageTrace = New-Object PSObject
11506$global:blankImageTrace | Add-Member NoteProperty TraceId $null
11507$global:blankImageTrace | Add-Member NoteProperty SiteId $null
11508$global:blankImageTrace | Add-Member NoteProperty ImageId $null
11509$global:blankImageTrace | Add-Member NoteProperty ImageVersion $null
11510$global:blankImageTrace | Add-Member NoteProperty Status $null
11511$global:blankImageTrace | Add-Member NoteProperty StatusTime $null
11512
11513Function Select-UnprocessedImageTrace ($siteId, $dbConn, $dbTran) {
11514 try {
11515 $cmd = New-Object System.Data.SqlClient.SqlCommand
11516
11517 $cmd.CommandText = "
11518 select top 1 traceid, siteid, imageid, imageversion, status, statustime
11519 from ImageTrace with (index = IX_ImageTrace_status_siteid)
11520 where siteid = @siteid
11521 and status = 'Unprocessed'
11522 "
11523
11524 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11525 $cmd.Parameters["@siteid"].Value = $siteId
11526
11527 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11528 $cmd = (ConvertTo-OracleCommand $cmd)
11529 }
11530
11531 $cmd.Connection = $dbConn
11532 $cmd.Transaction = $dbTran
11533
11534 $reader = $cmd.ExecuteReader()
11535
11536 if ($reader.Read()) {
11537 $imageTrace = $global:blankImageTrace.PSObject.Copy()
11538
11539 $imageTrace.TraceId = ConvertTo-PsType $reader[0]
11540 $imageTrace.SiteId = ConvertTo-PsType $reader[1]
11541 $imageTrace.ImageId = ConvertTo-PsType $reader[2]
11542 $imageTrace.ImageVersion = ConvertTo-PsType $reader[3]
11543 $imageTrace.Status = ConvertTo-PsType $reader[4]
11544 $imageTrace.StatusTime = ConvertTo-PsType $reader[5]
11545 }
11546 else {
11547 $imageTrace = $null
11548 }
11549
11550 return $imageTrace
11551 }
11552 catch {
11553 throw ("Error in Select-UnprocessedImageTrace: " + $error[0])
11554 }
11555 finally {
11556 if ($reader) {$reader.Close()}
11557 }
11558} # Select-UnprocessedImageTrace
11559
11560
11561Function Update-ImageTrace ($imageTrace, $dbConn, $dbTran) {
11562 try {
11563 $cmd = New-Object System.Data.SqlClient.SqlCommand
11564
11565 $cmd.CommandText = "
11566 update ImageTrace
11567 set status = @status, statustime = @statustime
11568 where traceid = @traceid
11569 "
11570
11571 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::VarChar) | Out-Null
11572 $cmd.Parameters["@status"].Value = $imageTrace.Status
11573
11574 $cmd.Parameters.Add("@statustime", [System.Data.SqlDbType]::DateTime) | Out-Null
11575 $cmd.Parameters["@statustime"].Value = (Get-Date)
11576
11577 $cmd.Parameters.Add("@traceid", [System.Data.SqlDbType]::Int) | Out-Null
11578 $cmd.Parameters["@traceid"].Value = $imageTrace.TraceId
11579
11580 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11581 $cmd = (ConvertTo-OracleCommand $cmd)
11582 }
11583
11584 $cmd.Connection = $dbConn
11585 $cmd.Transaction = $dbTran
11586
11587 $rowsAffected = $cmd.ExecuteNonQuery()
11588
11589 return $rowsAffected
11590 }
11591 catch {
11592 throw ("Error in Update-ImageTrace: " + $error[0])
11593 }
11594} # Update-ImageTrace
11595
11596
11597Function Select-ImageTraceCount ($siteId, $dbConn, $dbTran) {
11598 try {
11599 $cmd = New-Object System.Data.SqlClient.SqlCommand
11600
11601 $cmd.CommandText = "
11602 select count(*)
11603 from ImageTrace
11604 where siteid = @siteid
11605 "
11606
11607 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11608 $cmd.Parameters["@siteid"].Value = $siteId
11609
11610 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11611 $cmd = (ConvertTo-OracleCommand $cmd)
11612 }
11613
11614 $cmd.Connection = $dbConn
11615 if ($dbTran) {$cmd.Transaction = $dbTran}
11616
11617 $count = ConvertTo-PsType $cmd.ExecuteScalar()
11618
11619 return $count
11620 }
11621 catch {
11622 throw ("Error in Select-ImageTraceCount: " + $error[0])
11623 }
11624} # Select-ImageTraceCount
11625
11626
11627Function Select-ImageTraceCountByStatus ($siteId, $status, $dbConn, $dbTran) {
11628 try {
11629 $cmd = New-Object System.Data.SqlClient.SqlCommand
11630
11631 $cmd.CommandText = "
11632 select count(*)
11633 from ImageTrace
11634 where siteid = @siteid
11635 and status = @status
11636 "
11637
11638 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11639 $cmd.Parameters["@siteid"].Value = $siteId
11640
11641 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::VarChar) | Out-Null
11642 $cmd.Parameters["@status"].Value = $status
11643
11644 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11645 $cmd = (ConvertTo-OracleCommand $cmd)
11646 }
11647
11648 $cmd.Connection = $dbConn
11649 if ($dbTran) {$cmd.Transaction = $dbTran}
11650
11651 $count = ConvertTo-PsType $cmd.ExecuteScalar()
11652
11653 return $count
11654 }
11655 catch {
11656 throw ("Error in Select-ImageTraceCountByStatus: " + $error[0])
11657 }
11658} # Select-ImageTraceCountByStatus
11659
11660
11661Function Reset-ImageTraceErrors ($siteId, $dbConn, $dbTran) {
11662 try {
11663 $cmd = New-Object System.Data.SqlClient.SqlCommand
11664
11665 $cmd.CommandText = "
11666 update ImageTrace
11667 set status = 'Unprocessed'
11668 where siteid = @siteid
11669 and status = 'Error'
11670 "
11671
11672 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11673 $cmd.Parameters["@siteid"].Value = $siteId
11674
11675 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11676 $cmd = (ConvertTo-OracleCommand $cmd)
11677 }
11678
11679 $cmd.Connection = $dbConn
11680 $cmd.Transaction = $dbTran
11681
11682 $cmd.ExecuteNonQuery() | Out-Null
11683 }
11684 catch {
11685 throw ("Error in Reset-ImageTraceErrors: " + $error[0])
11686 }
11687} # Reset-ImageTraceErrors
11688
11689
11690# Ensures new images in Production are traced when reusing the Sync DB that was used in Test.
11691# The filter on statustime keeps us from deleting records that were processed while this
11692# statement was running. This is necessary, because the Trace script doesn't use a distributed
11693# transaction when inserting into TracerImageIgnore and updating ImageTrace.
11694Function Delete-UnconfirmedTraceCompletions ($master, $satellite, $syncDb, $syncTran) {
11695 try {
11696 $currentTime = Get-Date
11697
11698 $cmd = New-Object System.Data.SqlClient.SqlCommand
11699
11700 $cmd.CommandText = "
11701 delete from ImageTrace
11702 where siteid = @siteid
11703 and status = 'Complete'
11704 and statustime < @statustime
11705 and not exists (
11706 select 1
11707 from {SatellitePrefix}TracerImageIgnore{SatelliteSuffix}
11708 where imageid = ImageTrace.imageid
11709 and imageversion = ImageTrace.imageversion
11710 )
11711 "
11712
11713 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11714 $cmd.Parameters["@siteid"].Value = $siteId
11715
11716 $cmd.Parameters.Add("@statustime", [System.Data.SqlDbType]::DateTime) | Out-Null
11717 $cmd.Parameters["@statustime"].Value = $currentTime
11718
11719 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Master" $master.DbConn
11720 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Satellite" $satellite.DbConn
11721
11722 if ($syncDb.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11723 $cmd = (ConvertTo-OracleCommand $cmd)
11724 }
11725
11726 $cmd.Connection = $syncDb
11727 $cmd.Transaction = $syncTran
11728 $cmd.CommandTimeout = 0
11729
11730 $cmd.ExecuteNonQuery() | Out-Null
11731 }
11732 catch {
11733 throw ("Error in Delete-UnconfirmedTraceCompletions: " + $error[0])
11734 }
11735} # Delete-UnconfirmedTraceCompletions
11736
11737
11738Function Gather-ImageTrace ($master, $satellite, $syncDb, $syncTran) {
11739 try {
11740 $cmd = New-Object System.Data.SqlClient.SqlCommand
11741
11742 $cmd.CommandText = "
11743 insert into ImageTrace (siteid, imageid, imageversion, status, statustime)
11744 select @satelliteid, iv_sat.imageid, iv_sat.imageversion, 'Unprocessed', @statustime
11745 from {SatellitePrefix}ImageVersion{SatelliteSuffix} iv_sat
11746 join {SatellitePrefix}Image{SatelliteSuffix} i_sat on i_sat.imageid = iv_sat.imageid
11747 where i_sat.type <> -1 -- Exclude RDAs
11748 and not exists (
11749 select 1
11750 from {SatellitePrefix}TracerImageIgnore{SatelliteSuffix}
11751 where imageid = iv_sat.imageid
11752 and imageversion = iv_sat.imageversion
11753 )
11754 and not exists (
11755 select 1
11756 from ImageTrace
11757 where siteid = @satelliteid
11758 and imageid = iv_sat.imageid
11759 and imageversion = iv_sat.imageversion
11760 )
11761 "
11762
11763 $cmd.Parameters.Add("@satelliteid", [System.Data.SqlDbType]::Int) | Out-Null
11764 $cmd.Parameters["@satelliteid"].Value = $satellite.SiteId
11765
11766 $cmd.Parameters.Add("@statustime", [System.Data.SqlDbType]::DateTime) | Out-Null
11767 $cmd.Parameters["@statustime"].Value = Get-Date
11768
11769 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Master" $master.DbConn
11770 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Satellite" $satellite.DbConn
11771
11772 if ($syncDb.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11773 $cmd = (ConvertTo-OracleCommand $cmd)
11774 }
11775
11776 $cmd.Connection = $syncDb
11777 $cmd.Transaction = $syncTran
11778 $cmd.CommandTimeout = 0
11779
11780 $cmd.ExecuteNonQuery() | Out-Null
11781 }
11782 catch {
11783 throw ("Error in Gather-ImageTrace: $($type): " + $error[0])
11784 }
11785} # Gather-ImageTrace
11786
11787
11788# Create blank object once, so it can be copied to create new instances.
11789# This results in huge performance gains.
11790$global:blankImageCopy = New-Object PSObject
11791$global:blankImageCopy | Add-Member NoteProperty CopyId $null
11792$global:blankImageCopy | Add-Member NoteProperty SiteId $null
11793$global:blankImageCopy | Add-Member NoteProperty ImageId $null
11794$global:blankImageCopy | Add-Member NoteProperty ImageVersion $null
11795$global:blankImageCopy | Add-Member NoteProperty Status $null
11796$global:blankImageCopy | Add-Member NoteProperty StatusTime $null
11797
11798Function Select-UnprocessedImageCopy ($siteId, $dbConn, $dbTran) {
11799 try {
11800 $cmd = New-Object System.Data.SqlClient.SqlCommand
11801
11802 $cmd.CommandText = "
11803 select top 1 copyid, siteid, imageid, imageversion, status, statustime
11804 from ImageCopy with (index = IX_ImageCopy_status_siteid)
11805 where siteid = @siteid
11806 and status = 'Unprocessed'
11807 "
11808
11809 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11810 $cmd.Parameters["@siteid"].Value = $siteId
11811
11812 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11813 $cmd = (ConvertTo-OracleCommand $cmd)
11814 }
11815
11816 $cmd.Connection = $dbConn
11817 $cmd.Transaction = $dbTran
11818
11819 $reader = $cmd.ExecuteReader()
11820
11821 if ($reader.Read()) {
11822 $imageCopy = $global:blankImageCopy.PSObject.Copy()
11823
11824 $imageCopy.CopyId = ConvertTo-PsType $reader[0]
11825 $imageCopy.SiteId = ConvertTo-PsType $reader[1]
11826 $imageCopy.ImageId = ConvertTo-PsType $reader[2]
11827 $imageCopy.ImageVersion = ConvertTo-PsType $reader[3]
11828 $imageCopy.Status = ConvertTo-PsType $reader[4]
11829 $imageCopy.StatusTime = ConvertTo-PsType $reader[5]
11830 }
11831 else {
11832 $imageCopy = $null
11833 }
11834
11835 return $imageCopy
11836 }
11837 catch {
11838 throw ("Error in Select-UnprocessedImageCopy: " + $error[0])
11839 }
11840 finally {
11841 if ($reader) {$reader.Close()}
11842 }
11843} # Select-UnprocessedImageCopy
11844
11845
11846Function Update-ImageCopy ($imageCopy, $dbConn, $dbTran) {
11847 try {
11848 $cmd = New-Object System.Data.SqlClient.SqlCommand
11849
11850 $cmd.CommandText = "
11851 update ImageCopy
11852 set status = @status, statustime = @statustime
11853 where copyid = @copyid
11854 "
11855
11856 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::VarChar) | Out-Null
11857 $cmd.Parameters["@status"].Value = $imageCopy.Status
11858
11859 $cmd.Parameters.Add("@statustime", [System.Data.SqlDbType]::DateTime) | Out-Null
11860 $cmd.Parameters["@statustime"].Value = (Get-Date)
11861
11862 $cmd.Parameters.Add("@copyid", [System.Data.SqlDbType]::Int) | Out-Null
11863 $cmd.Parameters["@copyid"].Value = $imageCopy.CopyId
11864
11865 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11866 $cmd = (ConvertTo-OracleCommand $cmd)
11867 }
11868
11869 $cmd.Connection = $dbConn
11870 $cmd.Transaction = $dbTran
11871
11872 $rowsAffected = $cmd.ExecuteNonQuery()
11873
11874 return $rowsAffected
11875 }
11876 catch {
11877 throw ("Error in Update-ImageCopy: " + $error[0])
11878 }
11879} # Update-ImageCopy
11880
11881
11882Function Select-ImageCopyCount ($siteId, $dbConn, $dbTran) {
11883 try {
11884 $cmd = New-Object System.Data.SqlClient.SqlCommand
11885
11886 $cmd.CommandText = "
11887 select count(*)
11888 from ImageCopy
11889 where siteid = @siteid
11890 "
11891
11892 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11893 $cmd.Parameters["@siteid"].Value = $siteId
11894
11895 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11896 $cmd = (ConvertTo-OracleCommand $cmd)
11897 }
11898
11899 $cmd.Connection = $dbConn
11900 if ($dbTran) {$cmd.Transaction = $dbTran}
11901
11902 $count = ConvertTo-PsType $cmd.ExecuteScalar()
11903
11904 return $count
11905 }
11906 catch {
11907 throw ("Error in Select-ImageCopyCount: " + $error[0])
11908 }
11909} # Select-ImageCopyCount
11910
11911
11912Function Select-ImageCopyCountByStatus ($siteId, $status, $dbConn, $dbTran) {
11913 try {
11914 $cmd = New-Object System.Data.SqlClient.SqlCommand
11915
11916 $cmd.CommandText = "
11917 select count(*)
11918 from ImageCopy
11919 where siteid = @siteid
11920 and status = @status
11921 "
11922
11923 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11924 $cmd.Parameters["@siteid"].Value = $siteId
11925
11926 $cmd.Parameters.Add("@status", [System.Data.SqlDbType]::VarChar) | Out-Null
11927 $cmd.Parameters["@status"].Value = $status
11928
11929 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11930 $cmd = (ConvertTo-OracleCommand $cmd)
11931 }
11932
11933 $cmd.Connection = $dbConn
11934 if ($dbTran) {$cmd.Transaction = $dbTran}
11935
11936 $count = ConvertTo-PsType $cmd.ExecuteScalar()
11937
11938 return $count
11939 }
11940 catch {
11941 throw ("Error in Select-ImageCopyCountByStatus: " + $error[0])
11942 }
11943} # Select-ImageCopyCountByStatus
11944
11945
11946Function Reset-ImageCopyErrors ($siteId, $dbConn, $dbTran) {
11947 try {
11948 $cmd = New-Object System.Data.SqlClient.SqlCommand
11949
11950 $cmd.CommandText = "
11951 update ImageCopy
11952 set status = 'Unprocessed'
11953 where siteid = @siteid
11954 and status = 'Error'
11955 "
11956
11957 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
11958 $cmd.Parameters["@siteid"].Value = $siteId
11959
11960 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
11961 $cmd = (ConvertTo-OracleCommand $cmd)
11962 }
11963
11964 $cmd.Connection = $dbConn
11965 $cmd.Transaction = $dbTran
11966
11967 $cmd.ExecuteNonQuery() | Out-Null
11968 }
11969 catch {
11970 throw ("Error in Reset-ImageCopyErrors: " + $error[0])
11971 }
11972} # Reset-ImageCopyErrors
11973
11974
11975Function Gather-ImageCopy ($master, $satellite, $syncDb, $syncTran) {
11976 try {
11977 $cmd = New-Object System.Data.SqlClient.SqlCommand
11978
11979 $cmd.CommandText = "
11980 insert into ImageCopy (siteid, imageid, imageversion, status, statustime)
11981 select @satelliteid, iv_sat.imageid, iv_sat.imageversion, 'Unprocessed', @statustime
11982 from {SatellitePrefix}ImageVersion{SatelliteSuffix} iv_sat
11983 join {SatellitePrefix}Image{SatelliteSuffix} i_sat on i_sat.imageid = iv_sat.imageid
11984 join {SatellitePrefix}Device{SatelliteSuffix} d_sat on d_sat.deviceid = iv_sat.nearlinedevice
11985 where i_sat.type <> -1 -- Exclude RDAs
11986 and d_sat.devicetype = 2
11987 and not exists (
11988 select 1
11989 from ImageCopy
11990 where siteid = @satelliteid
11991 and imageid = iv_sat.imageid
11992 and imageversion = iv_sat.imageversion
11993 )
11994 "
11995
11996 $cmd.Parameters.Add("@satelliteid", [System.Data.SqlDbType]::Int) | Out-Null
11997 $cmd.Parameters["@satelliteid"].Value = $satellite.SiteId
11998
11999 $cmd.Parameters.Add("@statustime", [System.Data.SqlDbType]::DateTime) | Out-Null
12000 $cmd.Parameters["@statustime"].Value = Get-Date
12001
12002 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Master" $master.DbConn
12003 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Satellite" $satellite.DbConn
12004
12005 if ($syncDb.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12006 $cmd = (ConvertTo-OracleCommand $cmd)
12007 }
12008
12009 $cmd.Connection = $syncDb
12010 $cmd.Transaction = $syncTran
12011 $cmd.CommandTimeout = 0
12012
12013 $cmd.ExecuteNonQuery() | Out-Null
12014 }
12015 catch {
12016 throw ("Error in Gather-ImageCopy: $($type): " + $error[0])
12017 }
12018} # Gather-ImageCopy
12019
12020
12021Function Update-FileOwners ($oldOwner, $newOwner, $dbConn) {
12022 try {
12023 $cmd = New-Object System.Data.SqlClient.SqlCommand
12024
12025 $cmd.CommandText = "
12026 update Files set owner = @newowner where owner = @oldowner
12027 "
12028
12029 $cmd.Parameters.Add("@newowner", [System.Data.SqlDbType]::Int) | Out-Null
12030 $cmd.Parameters["@newowner"].Value = $newOwner
12031
12032 $cmd.Parameters.Add("@oldowner", [System.Data.SqlDbType]::Int) | Out-Null
12033 $cmd.Parameters["@oldowner"].Value = $oldOwner
12034
12035 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12036 $cmd = (ConvertTo-OracleCommand $cmd)
12037 }
12038
12039 $cmd.Connection = $dbConn
12040 $cmd.CommandTimeout = 600
12041
12042 $cmd.ExecuteNonQuery() | Out-Null
12043 }
12044 catch {
12045 throw ("Error in Update-FileOwners: " + $error[0])
12046 }
12047} # Update-FileOwners
12048
12049
12050Function Update-ImageSetOwners ($oldOwner, $newOwner, $dbConn) {
12051 try {
12052 $cmd = New-Object System.Data.SqlClient.SqlCommand
12053
12054 $cmd.CommandText = "
12055 update ImageSet set owner = @newowner where owner = @oldowner
12056 "
12057
12058 $cmd.Parameters.Add("@newowner", [System.Data.SqlDbType]::Int) | Out-Null
12059 $cmd.Parameters["@newowner"].Value = $newOwner
12060
12061 $cmd.Parameters.Add("@oldowner", [System.Data.SqlDbType]::Int) | Out-Null
12062 $cmd.Parameters["@oldowner"].Value = $oldOwner
12063
12064 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12065 $cmd = (ConvertTo-OracleCommand $cmd)
12066 }
12067
12068 $cmd.Connection = $dbConn
12069 $cmd.CommandTimeout = 600
12070
12071 $cmd.ExecuteNonQuery() | Out-Null
12072 }
12073 catch {
12074 throw ("Error in Update-ImageSetOwners: " + $error[0])
12075 }
12076} # Update-ImageSetOwners
12077
12078
12079Function Update-BatchOwners ($oldOwner, $newOwner, $dbConn) {
12080 try {
12081 $cmd = New-Object System.Data.SqlClient.SqlCommand
12082
12083 $cmd.CommandText = "
12084 update Batches set owner = @newowner where owner = @oldowner
12085 "
12086
12087 $cmd.Parameters.Add("@newowner", [System.Data.SqlDbType]::Int) | Out-Null
12088 $cmd.Parameters["@newowner"].Value = ConvertTo-DbNull $newOwner
12089
12090 $cmd.Parameters.Add("@oldowner", [System.Data.SqlDbType]::Int) | Out-Null
12091 $cmd.Parameters["@oldowner"].Value = ConvertTo-DbNull $oldOwner
12092
12093 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12094 $cmd = (ConvertTo-OracleCommand $cmd)
12095 }
12096
12097 $cmd.Connection = $dbConn
12098 $cmd.CommandTimeout = 600
12099
12100 $cmd.ExecuteNonQuery() | Out-Null
12101 }
12102 catch {
12103 throw ("Error in Update-BatchOwners: " + $error[0])
12104 }
12105} # Update-BatchOwners
12106
12107
12108Function Update-BoxInfoOwners ($oldOwner, $newOwner, $dbConn) {
12109 try {
12110 $cmd = New-Object System.Data.SqlClient.SqlCommand
12111
12112 $cmd.CommandText = "
12113 update BoxInfo set owner = @newowner where owner = @oldowner
12114 "
12115
12116 $cmd.Parameters.Add("@newowner", [System.Data.SqlDbType]::Int) | Out-Null
12117 $cmd.Parameters["@newowner"].Value = ConvertTo-DbNull $newOwner
12118
12119 $cmd.Parameters.Add("@oldowner", [System.Data.SqlDbType]::Int) | Out-Null
12120 $cmd.Parameters["@oldowner"].Value = ConvertTo-DbNull $oldOwner
12121
12122 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12123 $cmd = (ConvertTo-OracleCommand $cmd)
12124 }
12125
12126 $cmd.Connection = $dbConn
12127 $cmd.CommandTimeout = 600
12128
12129 $cmd.ExecuteNonQuery() | Out-Null
12130 }
12131 catch {
12132 throw ("Error in Update-BoxInfoOwners: " + $error[0])
12133 }
12134} # Update-BoxInfoOwners
12135
12136
12137Function Update-ImageVersionSiteIds ($oldSiteId, $newSiteId, $dbConn) {
12138 try {
12139 $cmd = New-Object System.Data.SqlClient.SqlCommand
12140
12141 $cmd.CommandText = "
12142 update ImageVersion set siteid = @newsiteid where siteid = @oldsiteid
12143 "
12144
12145 $cmd.Parameters.Add("@newsiteid", [System.Data.SqlDbType]::Int) | Out-Null
12146 $cmd.Parameters["@newsiteid"].Value = ConvertTo-DbNull $newSiteId
12147
12148 $cmd.Parameters.Add("@oldsiteid", [System.Data.SqlDbType]::Int) | Out-Null
12149 $cmd.Parameters["@oldsiteid"].Value = ConvertTo-DbNull $oldSiteId
12150
12151 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12152 $cmd = (ConvertTo-OracleCommand $cmd)
12153 }
12154
12155 $cmd.Connection = $dbConn
12156 $cmd.CommandTimeout = 600
12157
12158 $cmd.ExecuteNonQuery() | Out-Null
12159 }
12160 catch {
12161 throw ("Error in Update-ImageVersionSiteIds: " + $error[0])
12162 }
12163} # Update-ImageVersionSiteIds
12164
12165
12166Function Delete-IncomingReplLogBySiteId ($siteId, $dbConn) {
12167 try {
12168 $cmd = New-Object System.Data.SqlClient.SqlCommand
12169
12170 $cmd.CommandText = "
12171 delete from IncomingReplLog where siteid = @siteid
12172 "
12173
12174 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
12175 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $siteId
12176
12177 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12178 $cmd = (ConvertTo-OracleCommand $cmd)
12179 }
12180
12181 $cmd.Connection = $dbConn
12182 $cmd.CommandTimeout = 600
12183
12184 $cmd.ExecuteNonQuery() | Out-Null
12185 }
12186 catch {
12187 throw ("Error in Delete-IncomingReplLogBySiteId: " + $error[0])
12188 }
12189} # Delete-IncomingReplLogBySiteId
12190
12191
12192Function Delete-ReplicationQueueBySiteId ($siteId, $dbConn) {
12193 try {
12194 $cmd = New-Object System.Data.SqlClient.SqlCommand
12195
12196 $cmd.CommandText = "
12197 delete from ReplicationQueue where siteid = @siteid
12198 "
12199
12200 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
12201 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $siteId
12202
12203 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12204 $cmd = (ConvertTo-OracleCommand $cmd)
12205 }
12206
12207 $cmd.Connection = $dbConn
12208 $cmd.CommandTimeout = 600
12209
12210 $cmd.ExecuteNonQuery() | Out-Null
12211 }
12212 catch {
12213 throw ("Error in Delete-ReplicationQueueBySiteId: " + $error[0])
12214 }
12215} # Delete-ReplicationQueueBySiteId
12216
12217
12218Function Delete-ReplTempObjectBySiteId ($siteId, $dbConn) {
12219 try {
12220 $cmd = New-Object System.Data.SqlClient.SqlCommand
12221
12222 $cmd.CommandText = "
12223 delete from ReplTempObject where siteid = @siteid
12224 "
12225
12226 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
12227 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $siteId
12228
12229 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12230 $cmd = (ConvertTo-OracleCommand $cmd)
12231 }
12232
12233 $cmd.Connection = $dbConn
12234 $cmd.CommandTimeout = 600
12235
12236 $cmd.ExecuteNonQuery() | Out-Null
12237 }
12238 catch {
12239 throw ("Error in Delete-ReplTempObjectBySiteId: " + $error[0])
12240 }
12241} # Delete-ReplTempObjectBySiteId
12242
12243
12244Function Delete-ReplTempPagesBySiteId ($siteId, $dbConn) {
12245 try {
12246 $cmd = New-Object System.Data.SqlClient.SqlCommand
12247
12248 $cmd.CommandText = "
12249 delete from ReplTempPages where siteid = @siteid
12250 "
12251
12252 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
12253 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $siteId
12254
12255 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12256 $cmd = (ConvertTo-OracleCommand $cmd)
12257 }
12258
12259 $cmd.Connection = $dbConn
12260 $cmd.CommandTimeout = 600
12261
12262 $cmd.ExecuteNonQuery() | Out-Null
12263 }
12264 catch {
12265 throw ("Error in Delete-ReplTempPagesBySiteId: " + $error[0])
12266 }
12267} # Delete-ReplTempPagesBySiteId
12268
12269
12270Function Delete-ReplTempTaskBySiteId ($siteId, $dbConn) {
12271 try {
12272 $cmd = New-Object System.Data.SqlClient.SqlCommand
12273
12274 $cmd.CommandText = "
12275 delete from ReplTempTask where siteid = @siteid
12276 "
12277
12278 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
12279 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $siteId
12280
12281 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12282 $cmd = (ConvertTo-OracleCommand $cmd)
12283 }
12284
12285 $cmd.Connection = $dbConn
12286 $cmd.CommandTimeout = 600
12287
12288 $cmd.ExecuteNonQuery() | Out-Null
12289 }
12290 catch {
12291 throw ("Error in Delete-ReplTempTaskBySiteId: " + $error[0])
12292 }
12293} # Delete-ReplTempTaskBySiteId
12294
12295
12296Function Update-KeyTypesToHighest ($masterDb, $satelliteDb, $syncDb) {
12297 try {
12298 $keyTypeArray = Select-KeyTypes $satelliteDb
12299
12300 $keyTypeArray | ForEach-Object {
12301 $satKeyType = $_
12302 $masterKeyType = Select-KeyType $satKeyType.KeyTypeId $masterDb
12303
12304 if ($satKeyType.NextKey -gt $masterKeyType.NextKey -or $masterKeyType -eq $null) {
12305 $satKeyType.KeyCount = 2147483647 - $satKeyType.NextKey
12306
12307 if (!(Update-KeyType $satKeyType $masterDb)) {Insert-KeyType $satKeyType $masterDb | Out-Null}
12308 }
12309 }
12310 }
12311 catch {
12312 throw ("Error in Update-KeyTypesToHighest: " + $error[0])
12313 }
12314} # Update-KeyTypesToHighest
12315
12316
12317Function Insert-MissingKeyTypes ($masterDb, $satelliteDb, $syncDb) {
12318 try {
12319 $cmd = New-Object System.Data.SqlClient.SqlCommand
12320
12321 $cmd.CommandText = "
12322 insert into {MasterPrefix}KeyTypes{MasterSuffix} (keytype, setid, nextkey, keycount)
12323 select keytype, setid, nextkey, keycount
12324 from {SatellitePrefix}KeyTypes{SatelliteSuffix} kt_sat
12325 where setid = 0
12326 and not exists (
12327 select 1
12328 from {MasterPrefix}KeyTypes{MasterSuffix}
12329 where keytype = kt_sat.keytype
12330 )
12331 "
12332
12333 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Master" $masterDb
12334 $cmd.CommandText = Replace-DbQualifier $cmd.CommandText "Satellite" $satelliteDb
12335
12336 if ($syncDb.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12337 $cmd = (ConvertTo-OracleCommand $cmd)
12338 }
12339
12340 $cmd.Connection = $syncDb
12341 $cmd.CommandTimeout = 0
12342
12343 $cmd.ExecuteNonQuery() | Out-Null
12344 }
12345 catch {
12346 throw ("Error in Insert-MissingKeyTypes: " + $error[0])
12347 }
12348} # Insert-MissingKeyTypes
12349
12350
12351Function Delete-Site ($siteId, $dbConn) {
12352 try {
12353 $cmd = New-Object System.Data.SqlClient.SqlCommand
12354
12355 $cmd.CommandText = "
12356 delete from Site where siteid = @siteid
12357 "
12358
12359 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
12360 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $siteId
12361
12362 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12363 $cmd = (ConvertTo-OracleCommand $cmd)
12364 }
12365
12366 $cmd.Connection = $dbConn
12367 $cmd.CommandTimeout = 600
12368
12369 $cmd.ExecuteNonQuery() | Out-Null
12370 }
12371 catch {
12372 throw ("Error in Delete-Site: " + $error[0])
12373 }
12374} # Delete-Site
12375
12376
12377Function Update-SiteUri ($siteId, $newUri, $dbConn) {
12378 try {
12379 $cmd = New-Object System.Data.SqlClient.SqlCommand
12380
12381 $cmd.CommandText = "
12382 update Site set siteuri = @siteuri where siteid = @siteid
12383 "
12384
12385 $cmd.Parameters.Add("@siteuri", [System.Data.SqlDbType]::VarChar) | Out-Null
12386 $cmd.Parameters["@siteuri"].Value = ConvertTo-DbNull $newUri
12387
12388 $cmd.Parameters.Add("@siteid", [System.Data.SqlDbType]::Int) | Out-Null
12389 $cmd.Parameters["@siteid"].Value = ConvertTo-DbNull $siteId
12390
12391 if ($dbConn.GetType() -eq [Oracle.DataAccess.Client.OracleConnection]) {
12392 $cmd = (ConvertTo-OracleCommand $cmd)
12393 }
12394
12395 $cmd.Connection = $dbConn
12396
12397 $cmd.ExecuteNonQuery() | Out-Null
12398 }
12399 catch {
12400 throw ("Error in Update-SiteUri: " + $error[0])
12401 }
12402} # Update-SiteUri